Add mpg attach feature to track app attachments

Previously, `mpg attach` only created a secret and deployed. Now,
it will create an explicit DB connection between the MPG and the
app in question. It uses a new endpoint in `ui-ex`

Author: aezell

internal/command/launch/plan/postgres_test.go

@@ -111,6 +111,10 @@ func (m *mockUIEXClient) RestoreManagedClusterBackup(ctx context.Context, cluste
 	return uiex.RestoreManagedClusterBackupResponse{}, nil
 }
 
+func (m *mockUIEXClient) CreateAttachment(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+	return uiex.CreateAttachmentResponse{}, nil
+}
+
 func (m *mockUIEXClient) CreateBuild(ctx context.Context, in uiex.CreateBuildRequest) (*uiex.BuildResponse, error) {
 	return &uiex.BuildResponse{}, nil
 }

internal/command/mpg/attach.go

@@ -281,6 +281,15 @@ func runAttach(ctx context.Context) error {
 		return err
 	}
 
+	// Create attachment record to track the cluster-app relationship
+	attachInput := uiex.CreateAttachmentInput{
+		AppName: appName,
+	}
+	if _, err := uiexClient.CreateAttachment(ctx, cluster.Id, attachInput); err != nil {
+		// Log warning but don't fail - the secret was set successfully
+		fmt.Fprintf(io.ErrOut, "Warning: failed to create attachment record: %v\n", err)
+	}
+
 	fmt.Fprintf(io.Out, "\nPostgres cluster %s is being attached to %s\n", cluster.Id, appName)
 	fmt.Fprintf(io.Out, "The following secret was added to %s:\n  %s=%s\n", appName, variableName, connectionUri)
 

internal/command/mpg/mpg_test.go

@@ -1216,6 +1216,262 @@ func TestCreateCommand_WithPGMajorVersion(t *testing.T) {
 	}
 }
 
+// Test CreateAttachment functionality
+func TestCreateAttachment(t *testing.T) {
+	ctx := setupTestContext()
+
+	clusterID := "test-cluster-123"
+
+	t.Run("successful attachment creation", func(t *testing.T) {
+		mockUiex := &mock.UiexClient{
+			CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+				assert.Equal(t, clusterID, clusterId)
+				assert.Equal(t, "test-app", input.AppName)
+				return uiex.CreateAttachmentResponse{
+					Data: struct {
+						Id               int64  `json:"id"`
+						AppId            int64  `json:"app_id"`
+						ManagedServiceId int64  `json:"managed_service_id"`
+						AttachedAt       string `json:"attached_at"`
+					}{
+						Id:               1,
+						AppId:            100,
+						ManagedServiceId: 200,
+						AttachedAt:       "2025-01-15T10:00:00Z",
+					},
+				}, nil
+			},
+		}
+
+		ctx := uiexutil.NewContextWithClient(ctx, mockUiex)
+
+		response, err := mockUiex.CreateAttachment(ctx, clusterID, uiex.CreateAttachmentInput{
+			AppName: "test-app",
+		})
+
+		require.NoError(t, err)
+		assert.Equal(t, int64(1), response.Data.Id)
+		assert.Equal(t, int64(100), response.Data.AppId)
+		assert.Equal(t, int64(200), response.Data.ManagedServiceId)
+		assert.Equal(t, "2025-01-15T10:00:00Z", response.Data.AttachedAt)
+	})
+
+	t.Run("idempotent - returns existing attachment", func(t *testing.T) {
+		mockUiex := &mock.UiexClient{
+			CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+				// Simulating the idempotent case where attachment already exists
+				return uiex.CreateAttachmentResponse{
+					Data: struct {
+						Id               int64  `json:"id"`
+						AppId            int64  `json:"app_id"`
+						ManagedServiceId int64  `json:"managed_service_id"`
+						AttachedAt       string `json:"attached_at"`
+					}{
+						Id:               42, // Existing attachment ID
+						AppId:            100,
+						ManagedServiceId: 200,
+						AttachedAt:       "2025-01-14T09:00:00Z", // Earlier timestamp
+					},
+				}, nil
+			},
+		}
+
+		ctx := uiexutil.NewContextWithClient(ctx, mockUiex)
+
+		response, err := mockUiex.CreateAttachment(ctx, clusterID, uiex.CreateAttachmentInput{
+			AppName: "already-attached-app",
+		})
+
+		require.NoError(t, err)
+		assert.Equal(t, int64(42), response.Data.Id)
+	})
+
+	t.Run("error - cluster not found", func(t *testing.T) {
+		mockUiex := &mock.UiexClient{
+			CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+				return uiex.CreateAttachmentResponse{}, fmt.Errorf("cluster %s not found", clusterId)
+			},
+		}
+
+		ctx := uiexutil.NewContextWithClient(ctx, mockUiex)
+
+		_, err := mockUiex.CreateAttachment(ctx, "nonexistent-cluster", uiex.CreateAttachmentInput{
+			AppName: "test-app",
+		})
+
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "not found")
+	})
+
+	t.Run("error - access denied", func(t *testing.T) {
+		mockUiex := &mock.UiexClient{
+			CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+				return uiex.CreateAttachmentResponse{}, fmt.Errorf("access denied: you don't have permission to attach cluster %s", clusterId)
+			},
+		}
+
+		ctx := uiexutil.NewContextWithClient(ctx, mockUiex)
+
+		_, err := mockUiex.CreateAttachment(ctx, clusterID, uiex.CreateAttachmentInput{
+			AppName: "test-app",
+		})
+
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "access denied")
+	})
+
+	t.Run("error - app not found", func(t *testing.T) {
+		mockUiex := &mock.UiexClient{
+			CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+				return uiex.CreateAttachmentResponse{}, fmt.Errorf("app not found")
+			},
+		}
+
+		ctx := uiexutil.NewContextWithClient(ctx, mockUiex)
+
+		_, err := mockUiex.CreateAttachment(ctx, clusterID, uiex.CreateAttachmentInput{
+			AppName: "nonexistent-app",
+		})
+
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "not found")
+	})
+}
+
+// Test attach command integration with CreateAttachment
+func TestAttachCommand_CreatesAttachment(t *testing.T) {
+	ctx := setupTestContext()
+
+	clusterID := "test-cluster-123"
+	appName := "test-app"
+
+	expectedCluster := uiex.ManagedCluster{
+		Id:     clusterID,
+		Name:   "test-cluster",
+		Region: "ord",
+		Status: "ready",
+		Organization: fly.Organization{
+			Slug: "test-org",
+		},
+	}
+
+	connectionURI := "postgresql://user:pass@host:5432/db"
+
+	// Track whether CreateAttachment was called
+	createAttachmentCalled := false
+	var capturedAppName string
+
+	mockUiex := &mock.UiexClient{
+		GetManagedClusterByIdFunc: func(ctx context.Context, id string) (uiex.GetManagedClusterResponse, error) {
+			assert.Equal(t, clusterID, id)
+			return uiex.GetManagedClusterResponse{
+				Data: expectedCluster,
+				Credentials: uiex.GetManagedClusterCredentialsResponse{
+					ConnectionUri: connectionURI,
+					User:          "fly-user",
+					Password:      "test-password",
+					DBName:        "fly_db",
+				},
+			}, nil
+		},
+		CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+			createAttachmentCalled = true
+			capturedAppName = input.AppName
+			assert.Equal(t, clusterID, clusterId)
+			return uiex.CreateAttachmentResponse{
+				Data: struct {
+					Id               int64  `json:"id"`
+					AppId            int64  `json:"app_id"`
+					ManagedServiceId int64  `json:"managed_service_id"`
+					AttachedAt       string `json:"attached_at"`
+				}{
+					Id:               1,
+					AppId:            100,
+					ManagedServiceId: 200,
+					AttachedAt:       "2025-01-15T10:00:00Z",
+				},
+			}, nil
+		},
+	}
+
+	ctx = uiexutil.NewContextWithClient(ctx, mockUiex)
+
+	// Simulate the attach command flow: get cluster, then create attachment
+	response, err := mockUiex.GetManagedClusterById(ctx, clusterID)
+	require.NoError(t, err)
+	assert.Equal(t, expectedCluster.Id, response.Data.Id)
+
+	// Create attachment (this simulates what runAttach does after setting secrets)
+	attachInput := uiex.CreateAttachmentInput{
+		AppName: appName,
+	}
+	_, err = mockUiex.CreateAttachment(ctx, clusterID, attachInput)
+	require.NoError(t, err)
+
+	// Verify CreateAttachment was called with correct app name
+	assert.True(t, createAttachmentCalled, "CreateAttachment should be called during attach")
+	assert.Equal(t, appName, capturedAppName, "App name should be passed to CreateAttachment")
+}
+
+// Test that attach command handles CreateAttachment errors gracefully
+func TestAttachCommand_HandlesAttachmentErrorGracefully(t *testing.T) {
+	ctx := setupTestContext()
+
+	clusterID := "test-cluster-123"
+	appName := "test-app"
+
+	expectedCluster := uiex.ManagedCluster{
+		Id:     clusterID,
+		Name:   "test-cluster",
+		Region: "ord",
+		Status: "ready",
+		Organization: fly.Organization{
+			Slug: "test-org",
+		},
+	}
+
+	connectionURI := "postgresql://user:pass@host:5432/db"
+
+	mockUiex := &mock.UiexClient{
+		GetManagedClusterByIdFunc: func(ctx context.Context, id string) (uiex.GetManagedClusterResponse, error) {
+			return uiex.GetManagedClusterResponse{
+				Data: expectedCluster,
+				Credentials: uiex.GetManagedClusterCredentialsResponse{
+					ConnectionUri: connectionURI,
+					User:          "fly-user",
+					Password:      "test-password",
+					DBName:        "fly_db",
+				},
+			}, nil
+		},
+		CreateAttachmentFunc: func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+			// Simulate a failure in creating attachment
+			return uiex.CreateAttachmentResponse{}, fmt.Errorf("failed to create attachment")
+		},
+	}
+
+	ctx = uiexutil.NewContextWithClient(ctx, mockUiex)
+
+	// Get cluster - should succeed
+	response, err := mockUiex.GetManagedClusterById(ctx, clusterID)
+	require.NoError(t, err)
+	assert.Equal(t, expectedCluster.Id, response.Data.Id)
+
+	// Create attachment - should fail but we handle it gracefully
+	attachInput := uiex.CreateAttachmentInput{
+		AppName: appName,
+	}
+	_, err = mockUiex.CreateAttachment(ctx, clusterID, attachInput)
+
+	// The error exists but in runAttach we just log a warning
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "failed to create attachment")
+
+	// In the actual implementation, this is handled as a warning:
+	// fmt.Fprintf(io.ErrOut, "Warning: failed to create attachment record: %v\n", err)
+	// The attach command still succeeds because the secret was set
+}
+
 // Test invalid PG major version error message
 func TestInvalidPGMajorVersion_Error(t *testing.T) {
 	invalidVersions := []int{15, 18, 14, 13, 19, 0, -1}

internal/mock/uiex_client.go

@@ -31,6 +31,7 @@ type UiexClient struct {
 	ListManagedClusterBackupsFunc          func(ctx context.Context, clusterID string) (uiex.ListManagedClusterBackupsResponse, error)
 	CreateManagedClusterBackupFunc         func(ctx context.Context, clusterID string, input uiex.CreateManagedClusterBackupInput) (uiex.CreateManagedClusterBackupResponse, error)
 	RestoreManagedClusterBackupFunc        func(ctx context.Context, clusterID string, input uiex.RestoreManagedClusterBackupInput) (uiex.RestoreManagedClusterBackupResponse, error)
+	CreateAttachmentFunc                   func(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error)
 	CreateBuildFunc                        func(ctx context.Context, in uiex.CreateBuildRequest) (*uiex.BuildResponse, error)
 	FinishBuildFunc                        func(ctx context.Context, in uiex.FinishBuildRequest) (*uiex.BuildResponse, error)
 	EnsureDepotBuilderFunc                 func(ctx context.Context, in uiex.EnsureDepotBuilderRequest) (*uiex.EnsureDepotBuilderResponse, error)
@@ -237,3 +238,10 @@ func (m *UiexClient) RestoreManagedClusterBackup(ctx context.Context, clusterID
 	}
 	return uiex.RestoreManagedClusterBackupResponse{}, nil
 }
+
+func (m *UiexClient) CreateAttachment(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error) {
+	if m.CreateAttachmentFunc != nil {
+		return m.CreateAttachmentFunc(ctx, clusterId, input)
+	}
+	return uiex.CreateAttachmentResponse{}, nil
+}

internal/uiex/managed_postgres.go

@@ -880,3 +880,61 @@ func (c *Client) DestroyCluster(ctx context.Context, orgSlug string, id string)
 		return fmt.Errorf("failed to destroy cluster (status %d): %s", res.StatusCode, string(body))
 	}
 }
+
+type CreateAttachmentInput struct {
+	AppName string `json:"app_name"`
+}
+
+type CreateAttachmentResponse struct {
+	Data struct {
+		Id               int64  `json:"id"`
+		AppId            int64  `json:"app_id"`
+		ManagedServiceId int64  `json:"managed_service_id"`
+		AttachedAt       string `json:"attached_at"`
+	} `json:"data"`
+}
+
+// CreateAttachment creates a ManagedServiceAttachment record linking an app to a managed Postgres cluster
+func (c *Client) CreateAttachment(ctx context.Context, clusterId string, input CreateAttachmentInput) (CreateAttachmentResponse, error) {
+	var response CreateAttachmentResponse
+	cfg := config.FromContext(ctx)
+	url := fmt.Sprintf("%s/api/v1/postgres/%s/attachments", c.baseUrl, clusterId)
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(input); err != nil {
+		return response, fmt.Errorf("failed to encode request body: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, &buf)
+	if err != nil {
+		return response, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Add("Authorization", "Bearer "+cfg.Tokens.GraphQL())
+	req.Header.Add("Content-Type", "application/json")
+
+	res, err := c.httpClient.Do(req)
+	if err != nil {
+		return response, err
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return response, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	switch res.StatusCode {
+	case http.StatusOK, http.StatusCreated:
+		if err = json.Unmarshal(body, &response); err != nil {
+			return response, fmt.Errorf("failed to decode response: %w", err)
+		}
+		return response, nil
+	case http.StatusNotFound:
+		return response, fmt.Errorf("cluster %s not found", clusterId)
+	case http.StatusForbidden:
+		return response, fmt.Errorf("access denied: you don't have permission to attach cluster %s", clusterId)
+	default:
+		return response, fmt.Errorf("failed to create attachment (status %d): %s", res.StatusCode, string(body))
+	}
+}

internal/uiexutil/client.go

@@ -30,6 +30,7 @@ type Client interface {
 	ListManagedClusterBackups(ctx context.Context, clusterID string) (uiex.ListManagedClusterBackupsResponse, error)
 	CreateManagedClusterBackup(ctx context.Context, clusterID string, input uiex.CreateManagedClusterBackupInput) (uiex.CreateManagedClusterBackupResponse, error)
 	RestoreManagedClusterBackup(ctx context.Context, clusterID string, input uiex.RestoreManagedClusterBackupInput) (uiex.RestoreManagedClusterBackupResponse, error)
+	CreateAttachment(ctx context.Context, clusterId string, input uiex.CreateAttachmentInput) (uiex.CreateAttachmentResponse, error)
 
 	// Builders
 	CreateBuild(ctx context.Context, in uiex.CreateBuildRequest) (*uiex.BuildResponse, error)