PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FIX (databases): Stop suggesting a read-only user when RLS would break pg_dump
Rostislav Dugin4e1ddc22ecd2
diff --git a/backend/internal/features/databases/controller.go b/backend/internal/features/databases/controller.goindex 726cce38..6571b1be 100644--- a/backend/internal/features/databases/controller.go+++ b/backend/internal/features/databases/controller.go@@ -30,7 +30,7 @@ func (c *DatabaseController) RegisterRoutes(router *gin.RouterGroup) {router.POST("/databases/:id/copy", c.CopyDatabase)router.GET("/databases/notifier/:id/is-using", c.IsNotifierUsing)router.GET("/databases/notifier/:id/databases-count", c.CountDatabasesByNotifier)- router.POST("/databases/is-readonly", c.IsUserReadOnly)+ router.POST("/databases/should-suggest-readonly-user", c.ShouldSuggestReadOnlyUser)router.POST("/databases/create-readonly-user", c.CreateReadOnlyUser)router.POST("/databases/create-replication-only-user", c.CreateReplicationOnlyUser)}@@ -387,20 +387,20 @@ func (c *DatabaseController) CopyDatabase(ctx *gin.Context) {ctx.JSON(http.StatusCreated, copiedDatabase)}-// IsUserReadOnly-// @Summary Check if database user is read-only-// @Description Check if current database credentials have only read (SELECT) privileges+// ShouldSuggestReadOnlyUser+// @Summary Check whether a limited backup user should be suggested+// @Description Report whether Databasus should offer to create a read-only (or replication-only) user for these credentials// @Tags databases// @Accept json// @Produce json// @Security BearerAuth// @Param request body Database true "Database configuration to check"-// @Success 200 {object} IsReadOnlyResponse+// @Success 200 {object} ShouldSuggestReadOnlyUserResponse// @Failure 400 {object} map[string]string// @Failure 401 {object} map[string]string// @Failure 403 {object} map[string]string-// @Router /databases/is-readonly [post]-func (c *DatabaseController) IsUserReadOnly(ctx *gin.Context) {+// @Router /databases/should-suggest-readonly-user [post]+func (c *DatabaseController) ShouldSuggestReadOnlyUser(ctx *gin.Context) {user, ok := users_middleware.GetUserFromContext(ctx)if !ok {ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})@@ -413,13 +413,20 @@ func (c *DatabaseController) IsUserReadOnly(ctx *gin.Context) {return}- isReadOnly, privileges, err := c.databaseService.IsUserReadOnly(ctx.Request.Context(), user, &request)+ shouldSuggestReadOnlyUser, privileges, err := c.databaseService.ShouldSuggestReadOnlyUser(+ ctx.Request.Context(),+ user,+ &request,+ )if err != nil {ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})return}- ctx.JSON(http.StatusOK, IsReadOnlyResponse{IsReadOnly: isReadOnly, Privileges: privileges})+ ctx.JSON(http.StatusOK, ShouldSuggestReadOnlyUserResponse{+ ShouldSuggestReadOnlyUser: shouldSuggestReadOnlyUser,+ Privileges: privileges,+ })}// CreateReadOnlyUserdiff --git a/backend/internal/features/databases/databases/mariadb/model.go b/backend/internal/features/databases/databases/mariadb/model.goindex b5c4ad6f..99e4f4dc 100644--- a/backend/internal/features/databases/databases/mariadb/model.go+++ b/backend/internal/features/databases/databases/mariadb/model.go@@ -317,7 +317,7 @@ func (m *MariadbDatabase) PopulateVersion(return nil}-func (m *MariadbDatabase) IsUserReadOnly(+func (m *MariadbDatabase) ShouldSuggestReadOnlyUser(ctx context.Context,logger *slog.Logger,encryptor encryption.FieldEncryptor,@@ -392,8 +392,9 @@ func (m *MariadbDatabase) IsUserReadOnly(privileges = append(privileges, priv)}- isReadOnly := len(privileges) == 0- return isReadOnly, privileges, nil+ shouldSuggestReadOnlyUser := len(privileges) > 0++ return shouldSuggestReadOnlyUser, privileges, nil}func (m *MariadbDatabase) CreateReadOnlyUser(diff --git a/backend/internal/features/databases/databases/mariadb/model_test.go b/backend/internal/features/databases/databases/mariadb/model_test.goindex e4e90ff1..3169099b 100644--- a/backend/internal/features/databases/databases/mariadb/model_test.go+++ b/backend/internal/features/databases/databases/mariadb/model_test.go@@ -20,7 +20,7 @@ type mariadbModelVersion struct {name stringversion tools.MariadbVersionimage string- runsRoutineGrantTest bool // Test_IsUserReadOnly_WithShowCreateRoutineGrant runs only on 11.4/11.8/12.0+ runsRoutineGrantTest bool // only 11.4/11.8/12.0 expose SHOW CREATE ROUTINE}var mariadbModelVersions = []mariadbModelVersion{@@ -46,8 +46,8 @@ func Test_MariadbModel_AcrossSupportedVersions(t *testing.T) {testTestConnectionSufficientPermissions(t, endpoint, dbVersion.version)})- t.Run("Test_IsUserReadOnly_AdminUser_ReturnsFalse", func(t *testing.T) {- testIsUserReadOnlyAdminUser(t, endpoint, dbVersion.version)+ t.Run("Test_ShouldSuggestReadOnlyUser_AdminUser_ReturnsTrue", func(t *testing.T) {+ testShouldSuggestReadOnlyUserAdminUser(t, endpoint, dbVersion.version)})t.Run("Test_CreateReadOnlyUser_UserCanReadButNotWrite", func(t *testing.T) {@@ -63,7 +63,7 @@ func Test_MariadbModel_AcrossSupportedVersions(t *testing.T) {})if dbVersion.runsRoutineGrantTest {- t.Run("Test_IsUserReadOnly_WithShowCreateRoutineGrant_ReturnsTrue", func(t *testing.T) {+ t.Run("Test_ShouldSuggestReadOnlyUser_WithShowCreateRoutineGrant_ReturnsFalse", func(t *testing.T) {testShowCreateRoutineGrant(t, endpoint, dbVersion.version)})}@@ -194,7 +194,7 @@ func testTestConnectionSufficientPermissions(assert.NoError(t, err)}-func testIsUserReadOnlyAdminUser(+func testShouldSuggestReadOnlyUserAdminUser(t *testing.T,endpoint containers.Endpoint,version tools.MariadbVersion,@@ -206,13 +206,13 @@ func testIsUserReadOnlyAdminUser(logger := slog.New(slog.NewTextHandler(os.Stdout, nil))ctx := t.Context()- isReadOnly, privileges, err := mariadbModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, privileges, err := mariadbModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.False(t, isReadOnly, "Root user should not be read-only")+ assert.True(t, shouldSuggestReadOnlyUser, "Root user must be offered a read-only user")assert.NotEmpty(t, privileges, "Root user should have privileges")}-func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {+func Test_ShouldSuggestReadOnlyUser_ReadOnlyUser_ReturnsFalse(t *testing.T) {container := connectToMariadbContainer(t, "mariadb:10.11", tools.MariadbVersion1011)defer container.DB.Close()@@ -245,9 +245,9 @@ func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {IsHttps: false,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.True(t, isReadOnly, "Read-only user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Read-only user must not be offered another one")assert.Empty(t, privileges, "Read-only user should have no write privileges")dropUserSafe(container.DB, username)@@ -305,13 +305,13 @@ func testCreateReadOnlyUserCanReadButNotWrite(IsHttps: false,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx,logger,nil,)assert.NoError(t, err)- assert.True(t, isReadOnly, "Created user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Created user must not be offered another one")assert.Empty(t, privileges, "Read-only user should have no write privileges")readOnlyDSN := fmt.Sprintf(@@ -816,16 +816,16 @@ func testShowCreateRoutineGrant(logger := slog.New(slog.NewTextHandler(os.Stdout, nil))- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(t.Context(),logger,nil,)assert.NoError(t, err)- assert.True(+ assert.False(t,- isReadOnly,- "SELECT + SHOW VIEW + SHOW CREATE ROUTINE must be read-only, got privileges=%v",+ shouldSuggestReadOnlyUser,+ "SELECT + SHOW VIEW + SHOW CREATE ROUTINE must not be offered a read-only user, got privileges=%v",privileges,)assert.Empty(t, privileges)diff --git a/backend/internal/features/databases/databases/mongodb/model.go b/backend/internal/features/databases/databases/mongodb/model.goindex 6f835d94..20d1090b 100644--- a/backend/internal/features/databases/databases/mongodb/model.go+++ b/backend/internal/features/databases/databases/mongodb/model.go@@ -293,7 +293,7 @@ func (m *MongodbDatabase) PopulateVersion(return nil}-func (m *MongodbDatabase) IsUserReadOnly(+func (m *MongodbDatabase) ShouldSuggestReadOnlyUser(ctx context.Context,logger *slog.Logger,encryptor encryption.FieldEncryptor,@@ -388,17 +388,17 @@ func (m *MongodbDatabase) IsUserReadOnly(users, ok := result["users"].(bson.A)if !ok || len(users) == 0 {- return true, detectedRoles, nil+ return false, detectedRoles, nil}user, ok := users[0].(bson.M)if !ok {- return true, detectedRoles, nil+ return false, detectedRoles, nil}roles, ok := user["roles"].(bson.A)if !ok {- return true, detectedRoles, nil+ return false, detectedRoles, nil}// Collect all role names and check for write roles@@ -416,7 +416,7 @@ func (m *MongodbDatabase) IsUserReadOnly(// Check if any detected role is a write rolefor _, roleName := range detectedRoles {if writeRoles[roleName] {- return false, detectedRoles, nil+ return true, detectedRoles, nil}}@@ -429,7 +429,7 @@ func (m *MongodbDatabase) IsUserReadOnly(}}if allRolesReadOnly && len(detectedRoles) > 0 {- return true, detectedRoles, nil+ return false, detectedRoles, nil}// Check inherited privileges for custom roles@@ -447,12 +447,12 @@ func (m *MongodbDatabase) IsUserReadOnly(privUsers, ok := privResult["users"].(bson.A)if !ok || len(privUsers) == 0 {- return true, detectedRoles, nil+ return false, detectedRoles, nil}privUser, ok := privUsers[0].(bson.M)if !ok {- return true, detectedRoles, nil+ return false, detectedRoles, nil}// Check inheritedPrivileges for write actions@@ -470,13 +470,13 @@ func (m *MongodbDatabase) IsUserReadOnly(for _, action := range actions {actionStr, ok := action.(string)if ok && writeActions[actionStr] {- return false, detectedRoles, nil+ return true, detectedRoles, nil}}}}- return true, detectedRoles, nil+ return false, detectedRoles, nil}func (m *MongodbDatabase) CreateReadOnlyUser(diff --git a/backend/internal/features/databases/databases/mongodb/model_test.go b/backend/internal/features/databases/databases/mongodb/model_test.goindex de82c882..fcecd6db 100644--- a/backend/internal/features/databases/databases/mongodb/model_test.go+++ b/backend/internal/features/databases/databases/mongodb/model_test.go@@ -49,8 +49,8 @@ func Test_MongodbModel_AcrossSupportedVersions(t *testing.T) {testTestConnectionSufficientPermissions(t, endpoint, dbVersion.version)})- t.Run("Test_IsUserReadOnly_AdminUser_ReturnsFalse", func(t *testing.T) {- testIsUserReadOnlyAdminUser(t, endpoint, dbVersion.version)+ t.Run("Test_ShouldSuggestReadOnlyUser_AdminUser_ReturnsTrue", func(t *testing.T) {+ testShouldSuggestReadOnlyUserAdminUser(t, endpoint, dbVersion.version)})t.Run("Test_CreateReadOnlyUser_UserCanReadButNotWrite", func(t *testing.T) {@@ -162,7 +162,7 @@ func testTestConnectionSufficientPermissions(assert.NoError(t, err)}-func testIsUserReadOnlyAdminUser(+func testShouldSuggestReadOnlyUserAdminUser(t *testing.T,endpoint containers.Endpoint,version tools.MongodbVersion,@@ -174,13 +174,13 @@ func testIsUserReadOnlyAdminUser(logger := slog.New(slog.NewTextHandler(os.Stdout, nil))ctx := t.Context()- isReadOnly, roles, err := mongodbModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, roles, err := mongodbModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.False(t, isReadOnly, "Root user should not be read-only")+ assert.True(t, shouldSuggestReadOnlyUser, "Root user must be offered a read-only user")assert.NotEmpty(t, roles, "Root user should have roles")}-func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {+func Test_ShouldSuggestReadOnlyUser_ReadOnlyUser_ReturnsFalse(t *testing.T) {container := connectToMongodbContainer(t, "mongo:7.0", tools.MongodbVersion7)defer container.Client.Disconnect(t.Context())@@ -209,9 +209,9 @@ func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {CpuCount: 1,}- isReadOnly, roles, err := readOnlyModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, roles, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.True(t, isReadOnly, "Read-only user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Read-only user must not be offered another one")assert.NotEmpty(t, roles, "Read-only user should have roles (read, backup)")dropUserSafe(container.Client, username, container.AuthDatabase)diff --git a/backend/internal/features/databases/databases/mysql/model.go b/backend/internal/features/databases/databases/mysql/model.goindex df2e9b83..72f49747 100644--- a/backend/internal/features/databases/databases/mysql/model.go+++ b/backend/internal/features/databases/databases/mysql/model.go@@ -316,7 +316,7 @@ func (m *MysqlDatabase) PopulateVersion(return nil}-func (m *MysqlDatabase) IsUserReadOnly(+func (m *MysqlDatabase) ShouldSuggestReadOnlyUser(ctx context.Context,logger *slog.Logger,encryptor encryption.FieldEncryptor,@@ -390,9 +390,9 @@ func (m *MysqlDatabase) IsUserReadOnly(privileges = append(privileges, priv)}- isReadOnly := len(privileges) == 0+ shouldSuggestReadOnlyUser := len(privileges) > 0- return isReadOnly, privileges, nil+ return shouldSuggestReadOnlyUser, privileges, nil}func (m *MysqlDatabase) CreateReadOnlyUser(diff --git a/backend/internal/features/databases/databases/mysql/model_test.go b/backend/internal/features/databases/databases/mysql/model_test.goindex 4c3101b9..7e792357 100644--- a/backend/internal/features/databases/databases/mysql/model_test.go+++ b/backend/internal/features/databases/databases/mysql/model_test.go@@ -44,8 +44,8 @@ func Test_MysqlModel_AcrossSupportedVersions(t *testing.T) {testTestConnectionSufficientPermissions(t, endpoint, dbVersion.version)})- t.Run("Test_IsUserReadOnly_AdminUser_ReturnsFalse", func(t *testing.T) {- testIsUserReadOnlyAdminUser(t, endpoint, dbVersion.version)+ t.Run("Test_ShouldSuggestReadOnlyUser_AdminUser_ReturnsTrue", func(t *testing.T) {+ testShouldSuggestReadOnlyUserAdminUser(t, endpoint, dbVersion.version)})t.Run("Test_CreateReadOnlyUser_UserCanReadButNotWrite", func(t *testing.T) {@@ -194,7 +194,7 @@ func testTestConnectionSufficientPermissions(assert.NoError(t, err)}-func testIsUserReadOnlyAdminUser(+func testShouldSuggestReadOnlyUserAdminUser(t *testing.T,endpoint containers.Endpoint,version tools.MysqlVersion,@@ -206,13 +206,13 @@ func testIsUserReadOnlyAdminUser(logger := slog.New(slog.NewTextHandler(os.Stdout, nil))ctx := t.Context()- isReadOnly, privileges, err := mysqlModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, privileges, err := mysqlModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.False(t, isReadOnly, "Root user should not be read-only")+ assert.True(t, shouldSuggestReadOnlyUser, "Root user must be offered a read-only user")assert.NotEmpty(t, privileges, "Root user should have privileges")}-func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {+func Test_ShouldSuggestReadOnlyUser_ReadOnlyUser_ReturnsFalse(t *testing.T) {container := connectToMysqlContainer(t, "mysql:8.0", tools.MysqlVersion80)defer container.DB.Close()@@ -245,9 +245,9 @@ func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {IsHttps: false,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.True(t, isReadOnly, "Read-only user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Read-only user must not be offered another one")assert.Empty(t, privileges, "Read-only user should have no write privileges")_, err = container.DB.Exec(fmt.Sprintf("DROP USER IF EXISTS '%s'@'%%'", username))@@ -302,13 +302,13 @@ func testCreateReadOnlyUserCanReadButNotWrite(IsHttps: false,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx,logger,nil,)assert.NoError(t, err)- assert.True(t, isReadOnly, "Created user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Created user must not be offered another one")assert.Empty(t, privileges, "Read-only user should have no write privileges")readOnlyDSN := fmt.Sprintf(diff --git a/backend/internal/features/databases/databases/postgresql/logical/model.go b/backend/internal/features/databases/databases/postgresql/logical/model.goindex f0e11dce..c86e6177 100644--- a/backend/internal/features/databases/databases/postgresql/logical/model.go+++ b/backend/internal/features/databases/databases/postgresql/logical/model.go@@ -295,21 +295,7 @@ func (p *PostgresqlLogicalDatabase) PopulateVersion(return nil}-// IsUserReadOnly checks if the database user has read-only privileges.-//-// This method performs a comprehensive security check by examining:-// - Role-level attributes (superuser, createrole, createdb, bypassrls, replication)-// - Database-level privileges (CREATE, TEMP)-// - Schema-level privileges (CREATE on any non-system schema)-// - Table-level write permissions (INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER)-// - Function-level privileges (EXECUTE on SECURITY DEFINER functions)-//-// A user is considered read-only only if they have ZERO write privileges-// across all levels. This ensures the database user follows the-// principle of least privilege for backup operations.-//-// Returns: (isReadOnly, detectedPrivileges, error)-func (p *PostgresqlLogicalDatabase) IsUserReadOnly(+func (p *PostgresqlLogicalDatabase) ShouldSuggestReadOnlyUser(ctx context.Context,logger *slog.Logger,encryptor encryption.FieldEncryptor,@@ -451,28 +437,67 @@ func (p *PostgresqlLogicalDatabase) IsUserReadOnly(privileges = append(privileges, "EXECUTE (SECURITY DEFINER)")}- isReadOnly := len(privileges) == 0- return isReadOnly, privileges, nil+ rowLevelSecurityTables, err := getRowLevelSecurityTables(ctx, conn, p.IncludeSchemas)+ if err != nil {+ return false, nil, err+ }++ shouldSuggestReadOnlyUser := len(privileges) > 0 && len(rowLevelSecurityTables) == 0++ return shouldSuggestReadOnlyUser, privileges, nil+}++// pg_dump runs with row_security = off and aborts rather than emit a partial dump, so a role+// without BYPASSRLS can never back these tables up.+func getRowLevelSecurityTables(+ ctx context.Context,+ conn *pgx.Conn,+ includeSchemas []string,+) ([]string, error) {+ query := `+ SELECT n.nspname || '.' || c.relname+ FROM pg_class c+ JOIN pg_namespace n ON n.oid = c.relnamespace+ WHERE c.relrowsecurity+ AND c.relkind = 'r'+ AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')+ AND n.nspname NOT LIKE 'pg_temp_%'+ AND n.nspname NOT LIKE 'pg_toast_temp_%'+ `++ var rows pgx.Rows+ var err error++ if len(includeSchemas) > 0 {+ rows, err = conn.Query(ctx, query+" AND n.nspname = ANY($1::text[]) ORDER BY 1", includeSchemas)+ } else {+ rows, err = conn.Query(ctx, query+" ORDER BY 1")+ }++ if err != nil {+ return nil, fmt.Errorf("failed to check row-level security: %w", err)+ }++ defer rows.Close()++ var rowLevelSecurityTables []string++ for rows.Next() {+ var table string+ if err := rows.Scan(&table); err != nil {+ return nil, fmt.Errorf("failed to scan row-level security table: %w", err)+ }++ rowLevelSecurityTables = append(rowLevelSecurityTables, table)+ }++ if err := rows.Err(); err != nil {+ return nil, fmt.Errorf("error iterating row-level security tables: %w", err)+ }++ return rowLevelSecurityTables, nil}-// CreateReadOnlyUser creates a new PostgreSQL user with read-only privileges.-//-// This method performs the following operations atomically in a single transaction:-// 1. Creates a PostgreSQL user with a UUID-based password-// 2. Revokes CREATE privilege on public schema from PUBLIC role-// 3. Grants CONNECT privilege on the database-// 4. Discovers all user-created schemas-// 5. Grants USAGE on all non-system schemas-// 6. Grants SELECT on all existing tables and sequences-// 7. Sets default privileges for future tables and sequences-// 8. Verifies user creation before committing-//-// Security features:-// - Username format: "databasus-{8-char-uuid}" for uniqueness-// - Password: Full UUID (36 characters) for strong entropy-// - Transaction safety: All operations rollback on any failure-// - Retry logic: Up to 3 attempts if username collision occurs-// - Pre-validation: Checks CREATEROLE privilege before starting transactionfunc (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(ctx context.Context,logger *slog.Logger,@@ -488,7 +513,8 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(}}()- // Pre-validate: Check if current user can create roles+ // Pre-validation runs on the bare connection so a refusal costs no transaction and leaks no+ // generated credentials.var canCreateRole, isSuperuser boolerr = conn.QueryRow(ctx, `SELECT rolcreaterole, rolsuper@@ -502,6 +528,18 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(return "", "", errors.New("current database user lacks CREATEROLE privilege")}+ rowLevelSecurityTables, err := getRowLevelSecurityTables(ctx, conn, p.IncludeSchemas)+ if err != nil {+ return "", "", err+ }++ if len(rowLevelSecurityTables) > 0 {+ return "", "", fmt.Errorf(+ "row-level security is enabled on %s; grant BYPASSRLS to a role you create yourself, or back up with a role that owns these tables",+ formatTruncatedTableList(rowLevelSecurityTables),+ )+ }+// Retry logic for username collisionmaxRetries := 3for attempt := range maxRetries {@@ -1189,3 +1227,16 @@ func isLocalhostAddress(host string) bool {// The entire 127.0.0.0/8 loopback range, not just 127.0.0.1return strings.HasPrefix(host, "127.")}++func formatTruncatedTableList(tables []string) string {+ const maxListedTables = 5+ if len(tables) <= maxListedTables {+ return strings.Join(tables, ", ")+ }++ return fmt.Sprintf(+ "%s and %d more",+ strings.Join(tables[:maxListedTables], ", "),+ len(tables)-maxListedTables,+ )+}diff --git a/backend/internal/features/databases/databases/postgresql/logical/model_test.go b/backend/internal/features/databases/databases/postgresql/logical/model_test.goindex 43e060a1..14dd6bb1 100644--- a/backend/internal/features/databases/databases/postgresql/logical/model_test.go+++ b/backend/internal/features/databases/databases/postgresql/logical/model_test.go@@ -11,6 +11,7 @@ import ("github.com/jmoiron/sqlx"_ "github.com/lib/pq""github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"postgresql_shared "databasus-backend/internal/features/databases/databases/postgresql/shared""databasus-backend/internal/features/sshtunnel"@@ -157,8 +158,8 @@ func Test_PostgresqlModel_AcrossSupportedVersions(t *testing.T) {testConnectionSufficientPermissions(t, endpoint, dbVersion.tag)})- t.Run("Test_IsUserReadOnly_AdminUser_ReturnsFalse", func(t *testing.T) {- testIsUserReadOnlyAdminUser(t, endpoint, dbVersion.tag)+ t.Run("Test_ShouldSuggestReadOnlyUser_AdminUser_ReturnsTrue", func(t *testing.T) {+ testShouldSuggestReadOnlyUserAdminUser(t, endpoint, dbVersion.tag)})t.Run("Test_CreateReadOnlyUser_UserCanReadButNotWrite", func(t *testing.T) {@@ -177,6 +178,18 @@ func Test_PostgresqlModel_AcrossSupportedVersions(t *testing.T) {testCreateReadOnlyUserPublicSchemaExistsButNoPermissions(t, endpoint, dbVersion.tag)})+ t.Run("Test_ShouldSuggestReadOnlyUser_WhenRlsTableInScope_DoesNotSuggest", func(t *testing.T) {+ testShouldSuggestReadOnlyUserWhenRlsTableInScope(t, endpoint, dbVersion.tag)+ })++ t.Run("Test_ShouldSuggestReadOnlyUser_WhenRlsTableOutsideIncludeSchemas_Suggests", func(t *testing.T) {+ testShouldSuggestReadOnlyUserWhenRlsTableOutsideIncludeSchemas(t, endpoint, dbVersion.tag)+ })++ t.Run("Test_CreateReadOnlyUser_WhenRlsTableInScope_ReturnsErrorAndCreatesNoRole", func(t *testing.T) {+ testCreateReadOnlyUserWhenRlsTableInScope(t, endpoint, dbVersion.tag)+ })+t.Run("Test_TestConnection_WhenUserMappingUnreadableAndFlagFalse_ReturnsError", func(t *testing.T) {testConnectionUserMappingUnreadableFlagFalse(t, endpoint, dbVersion.tag)})@@ -392,7 +405,7 @@ func testConnectionSufficientPermissions(t *testing.T, endpoint containers.Endpoassert.NoError(t, err)}-func testIsUserReadOnlyAdminUser(t *testing.T, endpoint containers.Endpoint, version string) {+func testShouldSuggestReadOnlyUserAdminUser(t *testing.T, endpoint containers.Endpoint, version string) {container := connectToPostgresEndpoint(t, endpoint)defer container.DB.Close()@@ -400,13 +413,13 @@ func testIsUserReadOnlyAdminUser(t *testing.T, endpoint containers.Endpoint, verlogger := slog.New(slog.NewTextHandler(os.Stdout, nil))ctx := t.Context()- isReadOnly, privileges, err := pgModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, privileges, err := pgModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.False(t, isReadOnly, "Admin user should not be read-only")+ assert.True(t, shouldSuggestReadOnlyUser, "Admin user must be offered a read-only user")assert.NotEmpty(t, privileges, "Admin user should have privileges")}-func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {+func Test_ShouldSuggestReadOnlyUser_ReadOnlyUser_ReturnsFalse(t *testing.T) {container := connectToPostgresContainer(t, "postgres:16")defer container.DB.Close()@@ -438,9 +451,9 @@ func Test_IsUserReadOnly_ReadOnlyUser_ReturnsTrue(t *testing.T) {CpuCount: 1,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(ctx, logger, nil)+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx, logger, nil)assert.NoError(t, err)- assert.True(t, isReadOnly, "Read-only user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Read-only user must not be offered another one")assert.Empty(t, privileges, "Read-only user should have no write privileges")_, err = container.DB.Exec(fmt.Sprintf(`DROP OWNED BY "%s" CASCADE`, username))@@ -487,13 +500,13 @@ func testCreateReadOnlyUserCanReadButNotWrite(t *testing.T, endpoint containers.SslMode: postgresql_shared.PostgresSslModeDisable,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx,logger,nil,)assert.NoError(t, err)- assert.True(t, isReadOnly, "Created user should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "Created user must not be offered another one")assert.Empty(t, privileges, "Read-only user should have no write privileges")readOnlyDSN := fmt.Sprintf(@@ -736,13 +749,13 @@ func testCreateReadOnlyUserWithPublicSchema(t *testing.T, endpoint containers.EnSslMode: postgresql_shared.PostgresSslModeDisable,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx,logger,nil,)assert.NoError(t, err)- assert.True(t, isReadOnly, "User should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "User must not be offered a read-only user")assert.Empty(t, privileges, "Read-only user should have no write privileges")readOnlyDSN := fmt.Sprintf(@@ -823,13 +836,13 @@ func testCreateReadOnlyUserWithoutPublicSchema(t *testing.T, endpoint containersSslMode: postgresql_shared.PostgresSslModeDisable,}- isReadOnly, privileges, err := readOnlyModel.IsUserReadOnly(+ shouldSuggestReadOnlyUser, privileges, err := readOnlyModel.ShouldSuggestReadOnlyUser(ctx,logger,nil,)assert.NoError(t, err)- assert.True(t, isReadOnly, "User should be read-only")+ assert.False(t, shouldSuggestReadOnlyUser, "User must not be offered a read-only user")assert.Empty(t, privileges, "Read-only user should have no write privileges")readOnlyDSN := fmt.Sprintf(@@ -2203,3 +2216,114 @@ func Test_Validate_WhenDatabasusOnLoopbackIsBehindALocalBastion_IsRejected(t *teassert.Error(t, database.Validate(), "bastion host %q must not bypass the guard", bastionHost)}}++func createRlsTable(t *testing.T, container *PostgresContainer, schema, table string) {+ t.Helper()++ if schema != "public" {+ _, err := container.DB.Exec(fmt.Sprintf(`CREATE SCHEMA IF NOT EXISTS %q`, schema))+ require.NoError(t, err)+ }++ _, err := container.DB.Exec(fmt.Sprintf(`CREATE TABLE %q.%q (id int)`, schema, table))+ require.NoError(t, err)++ _, err = container.DB.Exec(fmt.Sprintf(`ALTER TABLE %q.%q ENABLE ROW LEVEL SECURITY`, schema, table))+ require.NoError(t, err)++ // The container is shared by every subtest of this version, so a leaked RLS table would+ // silently flip the verdict for all of them.+ t.Cleanup(func() {+ if _, cleanupErr := container.DB.Exec(+ fmt.Sprintf(`DROP TABLE IF EXISTS %q.%q CASCADE`, schema, table),+ ); cleanupErr != nil {+ t.Logf("failed to drop row-level security table: %v", cleanupErr)+ }+ if schema != "public" {+ if _, cleanupErr := container.DB.Exec(+ fmt.Sprintf(`DROP SCHEMA IF EXISTS %q CASCADE`, schema),+ ); cleanupErr != nil {+ t.Logf("failed to drop row-level security schema: %v", cleanupErr)+ }+ }+ })+}++func testShouldSuggestReadOnlyUserWhenRlsTableInScope(+ t *testing.T,+ endpoint containers.Endpoint,+ version string,+) {+ container := connectToPostgresEndpoint(t, endpoint)+ t.Cleanup(func() {+ if closeErr := container.DB.Close(); closeErr != nil {+ t.Logf("failed to close connection: %v", closeErr)+ }+ })++ createRlsTable(t, container, "public", "rls_in_scope")++ pgModel := createPostgresModel(container)+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ shouldSuggestReadOnlyUser, privileges, err := pgModel.ShouldSuggestReadOnlyUser(t.Context(), logger, nil)+ require.NoError(t, err)+ assert.False(t, shouldSuggestReadOnlyUser, "row-level security must suppress the suggestion")+ assert.NotEmpty(t, privileges, "the admin user is still privileged, only the suggestion is suppressed")+}++func testShouldSuggestReadOnlyUserWhenRlsTableOutsideIncludeSchemas(+ t *testing.T,+ endpoint containers.Endpoint,+ version string,+) {+ container := connectToPostgresEndpoint(t, endpoint)+ t.Cleanup(func() {+ if closeErr := container.DB.Close(); closeErr != nil {+ t.Logf("failed to close connection: %v", closeErr)+ }+ })++ createRlsTable(t, container, "rls_excluded_schema", "rls_out_of_scope")++ pgModel := createPostgresModel(container)+ pgModel.IncludeSchemas = []string{"public"}+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ shouldSuggestReadOnlyUser, _, err := pgModel.ShouldSuggestReadOnlyUser(t.Context(), logger, nil)+ require.NoError(t, err)+ assert.True(t, shouldSuggestReadOnlyUser, "row-level security outside the backed-up schemas is irrelevant")+}++func testCreateReadOnlyUserWhenRlsTableInScope(+ t *testing.T,+ endpoint containers.Endpoint,+ version string,+) {+ container := connectToPostgresEndpoint(t, endpoint)+ t.Cleanup(func() {+ if closeErr := container.DB.Close(); closeErr != nil {+ t.Logf("failed to close connection: %v", closeErr)+ }+ })++ createRlsTable(t, container, "public", "rls_blocks_creation")++ pgModel := createPostgresModel(container)+ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ const countDatabasusRolesQuery = `SELECT COUNT(*) FROM pg_roles WHERE rolname LIKE 'databasus-%'`++ var roleCountBeforeRefusal int+ require.NoError(t, container.DB.Get(&roleCountBeforeRefusal, countDatabasusRolesQuery))++ createdUsername, createdPassword, err := pgModel.CreateReadOnlyUser(t.Context(), logger, nil)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "public.rls_blocks_creation")+ assert.Empty(t, createdUsername)+ assert.Empty(t, createdPassword)++ var roleCountAfterRefusal int+ require.NoError(t, container.DB.Get(&roleCountAfterRefusal, countDatabasusRolesQuery))+ assert.Equal(t, roleCountBeforeRefusal, roleCountAfterRefusal, "refusal must not leave a role behind")+}diff --git a/backend/internal/features/databases/databases/postgresql/physical/model.go b/backend/internal/features/databases/databases/postgresql/physical/model.goindex b2e826b8..d44ba68f 100644--- a/backend/internal/features/databases/databases/postgresql/physical/model.go+++ b/backend/internal/features/databases/databases/postgresql/physical/model.go@@ -558,16 +558,10 @@ func (p *PostgresqlPhysicalDatabase) GetClusterSizeMb(return float64(sizeBytes) / (1024 * 1024), nil}-// IsUserReplicationOnly reports whether the configured user has only-// LOGIN + REPLICATION (or its cloud equivalent) and nothing more. Mirrors-// logical's IsUserReadOnly but tuned for physical: cloud admin roles-// (rds_superuser, azure_pg_admin, cloudsqlsuperuser) count as "excessive"-// even though they don't flip rolsuper on managed PG.-//-// Returns (isMinimal, excessivePrivileges, error). REPLICATION itself is the-// baseline and is NOT in the excessive list — it is validated separately by-// TestReplicationConnection.-func (p *PostgresqlPhysicalDatabase) IsUserReplicationOnly(+// Cloud admin roles (rds_superuser, azure_pg_admin, cloudsqlsuperuser) count as excessive even+// though they don't flip rolsuper on managed PG. REPLICATION itself is the baseline and is not+// excessive - it is validated separately by TestReplicationConnection.+func (p *PostgresqlPhysicalDatabase) ShouldSuggestReplicationOnlyUser(ctx context.Context,logger *slog.Logger,encryptor encryption.FieldEncryptor,@@ -718,7 +712,7 @@ func (p *PostgresqlPhysicalDatabase) IsUserReplicationOnly(excessive = append(excessive, "EXECUTE (SECURITY DEFINER)")}- return len(excessive) == 0, excessive, nil+ return len(excessive) > 0, excessive, nil}// CreateReplicationOnlyUser provisions a fresh role with exactlydiff --git a/backend/internal/features/databases/databases/postgresql/physical/model_test.go b/backend/internal/features/databases/databases/postgresql/physical/model_test.goindex ba5b89c3..00db2896 100644--- a/backend/internal/features/databases/databases/postgresql/physical/model_test.go+++ b/backend/internal/features/databases/databases/postgresql/physical/model_test.go@@ -672,7 +672,7 @@ func Test_GetClusterSizeMb_ReturnsPositiveValue(t *testing.T) {}}-func Test_IsUserReplicationOnly_DetectsSuperuser(t *testing.T) {+func Test_ShouldSuggestReplicationOnlyUser_DetectsSuperuser(t *testing.T) {for _, fx := range physicalFixtures() {t.Run(fx.name, func(t *testing.T) {if fx.port() == "" {@@ -681,15 +681,19 @@ func Test_IsUserReplicationOnly_DetectsSuperuser(t *testing.T) {m := newTestModel(t, fx.port())- isMinimal, excessive, err := m.IsUserReplicationOnly(context.Background(), testLogger(), nil)+ shouldSuggestReplicationOnlyUser, excessive, err := m.ShouldSuggestReplicationOnlyUser(+ context.Background(),+ testLogger(),+ nil,+ )require.NoError(t, err)- assert.False(t, isMinimal)+ assert.True(t, shouldSuggestReplicationOnlyUser)assert.Contains(t, excessive, "SUPERUSER")})}}-func Test_IsUserReplicationOnly_TrueForFreshlyCreatedReplicationUser(t *testing.T) {+func Test_ShouldSuggestReplicationOnlyUser_FalseForFreshlyCreatedReplicationUser(t *testing.T) {for _, fx := range physicalFixtures() {t.Run(fx.name, func(t *testing.T) {if fx.port() == "" {@@ -715,15 +719,19 @@ func Test_IsUserReplicationOnly_TrueForFreshlyCreatedReplicationUser(t *testing.m.Username = usernamem.Password = password- isMinimal, excessive, err := m.IsUserReplicationOnly(context.Background(), testLogger(), nil)+ shouldSuggestReplicationOnlyUser, excessive, err := m.ShouldSuggestReplicationOnlyUser(+ context.Background(),+ testLogger(),+ nil,+ )require.NoError(t, err)- assert.True(t, isMinimal, "excessive=%v", excessive)+ assert.False(t, shouldSuggestReplicationOnlyUser, "excessive=%v", excessive)assert.Empty(t, excessive)})}}-func Test_IsUserReplicationOnly_DetectsTableWritePrivilege(t *testing.T) {+func Test_ShouldSuggestReplicationOnlyUser_DetectsTableWritePrivilege(t *testing.T) {for _, fx := range physicalFixtures() {t.Run(fx.name, func(t *testing.T) {if fx.port() == "" {@@ -753,9 +761,13 @@ func Test_IsUserReplicationOnly_DetectsTableWritePrivilege(t *testing.T) {m.Username = usernamem.Password = password- isMinimal, excessive, err := m.IsUserReplicationOnly(context.Background(), testLogger(), nil)+ shouldSuggestReplicationOnlyUser, excessive, err := m.ShouldSuggestReplicationOnlyUser(+ context.Background(),+ testLogger(),+ nil,+ )require.NoError(t, err)- assert.False(t, isMinimal)+ assert.True(t, shouldSuggestReplicationOnlyUser)assert.Contains(t, excessive, "INSERT")})}@@ -1001,7 +1013,7 @@ func Test_CreateReplicationOnlyUser_OnSimulatedRds_GrantsRdsReplicationMembershi}}-func Test_IsUserReplicationOnly_OnSimulatedRds_FlagsRdsSuperuserMembership(t *testing.T) {+func Test_ShouldSuggestReplicationOnlyUser_OnSimulatedRds_FlagsRdsSuperuserMembership(t *testing.T) {for _, fx := range physicalFixtures() {t.Run(fx.name, func(t *testing.T) {if fx.port() == "" {@@ -1015,14 +1027,14 @@ func Test_IsUserReplicationOnly_OnSimulatedRds_FlagsRdsSuperuserMembership(t *tem := newTestModel(t, fx.port())- _, excessive, err := m.IsUserReplicationOnly(context.Background(), testLogger(), nil)+ _, excessive, err := m.ShouldSuggestReplicationOnlyUser(context.Background(), testLogger(), nil)require.NoError(t, err)assert.Contains(t, excessive, "rds_superuser (RDS admin)")})}}-func Test_IsUserReplicationOnly_OnSimulatedAzure_FlagsAzurePgAdminMembership(t *testing.T) {+func Test_ShouldSuggestReplicationOnlyUser_OnSimulatedAzure_FlagsAzurePgAdminMembership(t *testing.T) {for _, fx := range physicalFixtures() {t.Run(fx.name, func(t *testing.T) {if fx.port() == "" {@@ -1036,14 +1048,14 @@ func Test_IsUserReplicationOnly_OnSimulatedAzure_FlagsAzurePgAdminMembership(t *m := newTestModel(t, fx.port())- _, excessive, err := m.IsUserReplicationOnly(context.Background(), testLogger(), nil)+ _, excessive, err := m.ShouldSuggestReplicationOnlyUser(context.Background(), testLogger(), nil)require.NoError(t, err)assert.Contains(t, excessive, "azure_pg_admin (Azure admin)")})}}-func Test_IsUserReplicationOnly_OnSimulatedGcp_FlagsCloudsqlSuperuserMembership(t *testing.T) {+func Test_ShouldSuggestReplicationOnlyUser_OnSimulatedGcp_FlagsCloudsqlSuperuserMembership(t *testing.T) {for _, fx := range physicalFixtures() {t.Run(fx.name, func(t *testing.T) {if fx.port() == "" {@@ -1057,7 +1069,7 @@ func Test_IsUserReplicationOnly_OnSimulatedGcp_FlagsCloudsqlSuperuserMembership(m := newTestModel(t, fx.port())- _, excessive, err := m.IsUserReplicationOnly(context.Background(), testLogger(), nil)+ _, excessive, err := m.ShouldSuggestReplicationOnlyUser(context.Background(), testLogger(), nil)require.NoError(t, err)assert.Contains(t, excessive, "cloudsqlsuperuser (GCP admin)")})diff --git a/backend/internal/features/databases/dto.go b/backend/internal/features/databases/dto.goindex 63b5a16d..f5dcc6fa 100644--- a/backend/internal/features/databases/dto.go+++ b/backend/internal/features/databases/dto.go@@ -5,7 +5,7 @@ type CreateReadOnlyUserResponse struct {Password string `json:"password"`}-type IsReadOnlyResponse struct {- IsReadOnly bool `json:"isReadOnly"`- Privileges []string `json:"privileges"`+type ShouldSuggestReadOnlyUserResponse struct {+ ShouldSuggestReadOnlyUser bool `json:"shouldSuggestReadOnlyUser"`+ Privileges []string `json:"privileges"`}diff --git a/backend/internal/features/databases/model.go b/backend/internal/features/databases/model.goindex 4377fa51..b0f3d23a 100644--- a/backend/internal/features/databases/model.go+++ b/backend/internal/features/databases/model.go@@ -180,24 +180,24 @@ func (d *Database) GetRawDbSizeMb(}}-func (d *Database) IsUserReadOnly(+func (d *Database) ShouldSuggestReadOnlyUser(ctx context.Context,logger *slog.Logger,encryptor encryption.FieldEncryptor,) (bool, []string, error) {switch d.Type {case DatabaseTypePostgresLogical:- return d.PostgresqlLogical.IsUserReadOnly(ctx, logger, encryptor)+ return d.PostgresqlLogical.ShouldSuggestReadOnlyUser(ctx, logger, encryptor)case DatabaseTypePostgresPhysical:- return d.PostgresqlPhysical.IsUserReplicationOnly(ctx, logger, encryptor)+ return d.PostgresqlPhysical.ShouldSuggestReplicationOnlyUser(ctx, logger, encryptor)case DatabaseTypeMysql:- return d.Mysql.IsUserReadOnly(ctx, logger, encryptor)+ return d.Mysql.ShouldSuggestReadOnlyUser(ctx, logger, encryptor)case DatabaseTypeMariadb:- return d.Mariadb.IsUserReadOnly(ctx, logger, encryptor)+ return d.Mariadb.ShouldSuggestReadOnlyUser(ctx, logger, encryptor)case DatabaseTypeMongodb:- return d.Mongodb.IsUserReadOnly(ctx, logger, encryptor)+ return d.Mongodb.ShouldSuggestReadOnlyUser(ctx, logger, encryptor)default:- return false, nil, errors.New("read-only check not supported for this database type")+ return false, nil, errors.New("limited user suggestion not supported for this database type")}}diff --git a/backend/internal/features/databases/service.go b/backend/internal/features/databases/service.goindex e55f7796..61449dc5 100644--- a/backend/internal/features/databases/service.go+++ b/backend/internal/features/databases/service.go@@ -681,7 +681,7 @@ func (s *DatabaseService) OnBeforeWorkspaceDeletion(workspaceID uuid.UUID) errorreturn nil}-func (s *DatabaseService) IsUserReadOnly(+func (s *DatabaseService) ShouldSuggestReadOnlyUser(ctx context.Context,user *users_models.User,database *Database,@@ -755,7 +755,7 @@ func (s *DatabaseService) IsUserReadOnly(defer tunneledDatabase.Close()- return tunneledDatabase.GetDatabaseThroughTunnel().IsUserReadOnly(tunnelCtx, logger, s.fieldEncryptor)+ return tunneledDatabase.GetDatabaseThroughTunnel().ShouldSuggestReadOnlyUser(tunnelCtx, logger, s.fieldEncryptor)}func (s *DatabaseService) CreateReadOnlyUser(diff --git a/backend/internal/features/tests/physical/postgresql/shared/helpers.go b/backend/internal/features/tests/physical/postgresql/shared/helpers.goindex 3ba1b7f3..b7ec7802 100644--- a/backend/internal/features/tests/physical/postgresql/shared/helpers.go+++ b/backend/internal/features/tests/physical/postgresql/shared/helpers.go@@ -340,10 +340,10 @@ func useReplicationOnlyUserViaAPI(physical.Username = provisioned.Usernamephysical.Password = provisioned.Password- isMinimal, excessivePrivileges, err := physical.IsUserReplicationOnly(+ shouldSuggestReplicationOnlyUser, excessivePrivileges, err := physical.ShouldSuggestReplicationOnlyUser(t.Context(), logger.GetLogger(), encryption.GetFieldEncryptor())require.NoError(t, err)- require.True(t, isMinimal,+ require.False(t, shouldSuggestReplicationOnlyUser,"backups must run through a replication-only user; excessive privileges: %v", excessivePrivileges)require.Empty(t, excessivePrivileges)}diff --git a/frontend/src/entity/databases/api/databaseApi.ts b/frontend/src/entity/databases/api/databaseApi.tsindex bbee621d..9bcab71d 100644--- a/frontend/src/entity/databases/api/databaseApi.ts+++ b/frontend/src/entity/databases/api/databaseApi.ts@@ -3,7 +3,7 @@ import RequestOptions from '../../../shared/api/RequestOptions';import { apiHelper } from '../../../shared/api/apiHelper';import type { CreateReadOnlyUserResponse } from '../model/CreateReadOnlyUserResponse';import type { Database } from '../model/Database';-import type { IsReadOnlyResponse } from '../model/IsReadOnlyResponse';+import type { ShouldSuggestReadOnlyUserResponse } from '../model/ShouldSuggestReadOnlyUserResponse';export const databaseApi = {async createDatabase(database: Database) {@@ -101,11 +101,11 @@ export const databaseApi = {.then((res) => res.count);},- async isUserReadOnly(database: Database) {+ async shouldSuggestReadOnlyUser(database: Database) {const requestOptions: RequestOptions = new RequestOptions();requestOptions.setBody(JSON.stringify(database));- return apiHelper.fetchPostJson<IsReadOnlyResponse>(- `${getApplicationServer()}/api/v1/databases/is-readonly`,+ return apiHelper.fetchPostJson<ShouldSuggestReadOnlyUserResponse>(+ `${getApplicationServer()}/api/v1/databases/should-suggest-readonly-user`,requestOptions,);},diff --git a/frontend/src/entity/databases/index.ts b/frontend/src/entity/databases/index.tsindex db6aae33..82eedbea 100644--- a/frontend/src/entity/databases/index.ts+++ b/frontend/src/entity/databases/index.ts@@ -35,5 +35,5 @@ export { MariadbVersion } from './model/mariadb/MariadbVersion';export { type MongodbDatabase } from './model/mongodb/MongodbDatabase';export { MongodbVersion } from './model/mongodb/MongodbVersion';export { disableSrvWhenTunneled } from './model/mongodb/disableSrvWhenTunneled';-export { type IsReadOnlyResponse } from './model/IsReadOnlyResponse';+export { type ShouldSuggestReadOnlyUserResponse } from './model/ShouldSuggestReadOnlyUserResponse';export { type CreateReadOnlyUserResponse } from './model/CreateReadOnlyUserResponse';diff --git a/frontend/src/entity/databases/model/IsReadOnlyResponse.ts b/frontend/src/entity/databases/model/IsReadOnlyResponse.tsdeleted file mode 100644index a356f036..00000000--- a/frontend/src/entity/databases/model/IsReadOnlyResponse.ts+++ /dev/null@@ -1,4 +0,0 @@-export interface IsReadOnlyResponse {- isReadOnly: boolean;- privileges: string[];-}diff --git a/frontend/src/entity/databases/model/ShouldSuggestReadOnlyUserResponse.ts b/frontend/src/entity/databases/model/ShouldSuggestReadOnlyUserResponse.tsnew file mode 100644index 00000000..47935fae--- /dev/null+++ b/frontend/src/entity/databases/model/ShouldSuggestReadOnlyUserResponse.ts@@ -0,0 +1,4 @@+export interface ShouldSuggestReadOnlyUserResponse {+ shouldSuggestReadOnlyUser: boolean;+ privileges: string[];+}diff --git a/frontend/src/features/databases/ui/CreateDatabaseComponent.tsx b/frontend/src/features/databases/ui/CreateDatabaseComponent.tsxindex ecba910a..8c651d32 100644--- a/frontend/src/features/databases/ui/CreateDatabaseComponent.tsx+++ b/frontend/src/features/databases/ui/CreateDatabaseComponent.tsx@@ -171,7 +171,7 @@ export const CreateDatabaseComponent = ({}}onGoBack={() => setStep('db-settings')}onSkipped={() => setStep('backup-config')}- onAlreadyExists={() => setStep('backup-config')}+ onReadOnlyUserNotSuggested={() => setStep('backup-config')}/>);}diff --git a/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsx b/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsxindex a82ea8d3..e4317bcb 100644--- a/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsx+++ b/frontend/src/features/databases/ui/edit/CreateReadOnlyComponent.tsx@@ -1,9 +1,10 @@-import { Button, Modal, Spin } from 'antd';+import { App, Button, Modal, Spin } from 'antd';import { useEffect, useState } from 'react';import {type Database,DatabaseType,+ type ShouldSuggestReadOnlyUserResponse,databaseApi,getDatabaseTypeLabel,} from '../../../../entity/databases';@@ -14,7 +15,7 @@ interface Props {onGoBack: () => void;onSkipped: () => void;- onAlreadyExists: () => void;+ onReadOnlyUserNotSuggested: () => void;}const PRIVILEGES_TRUNCATE_LENGTH = 50;@@ -24,9 +25,11 @@ export const CreateReadOnlyComponent = ({onReadOnlyUserUpdated,onGoBack,onSkipped,- onAlreadyExists,+ onReadOnlyUserNotSuggested,}: Props) => {- const [isCheckingReadOnlyUser, setIsCheckingReadOnlyUser] = useState(false);+ const { message } = App.useApp();++ const [isCheckingReadOnlyUserSuggestion, setIsCheckingReadOnlyUserSuggestion] = useState(false);const [isCreatingReadOnlyUser, setIsCreatingReadOnlyUser] = useState(false);const [isShowSkipConfirmation, setShowSkipConfirmation] = useState(false);const [privileges, setPrivileges] = useState<string[]>([]);@@ -42,16 +45,15 @@ export const CreateReadOnlyComponent = ({const privilegesLabel = isMongodb ? 'roles' : 'privileges';const userKindNoun = isPhysicalPostgres ? 'replication-only user' : 'read-only user';- const checkReadOnlyUser = async (): Promise<boolean> => {- try {- const response = await databaseApi.isUserReadOnly(database);- setPrivileges(response.privileges || []);- return response.isReadOnly;- } catch (e) {- alert((e as Error).message);- return false;- }- };+ const fetchReadOnlyUserSuggestion =+ async (): Promise<ShouldSuggestReadOnlyUserResponse | null> => {+ try {+ return await databaseApi.shouldSuggestReadOnlyUser(database);+ } catch (e) {+ message.error((e as Error).message);+ return null;+ }+ };const getPrivilegesDisplay = () => {const fullText = privileges.join(', ');@@ -94,7 +96,7 @@ export const CreateReadOnlyComponent = ({onReadOnlyUserUpdated(database);} catch (e) {- alert((e as Error).message);+ message.error((e as Error).message);}setIsCreatingReadOnlyUser(false);@@ -111,19 +113,23 @@ export const CreateReadOnlyComponent = ({useEffect(() => {const run = async () => {- setIsCheckingReadOnlyUser(true);+ setIsCheckingReadOnlyUserSuggestion(true);++ const readOnlyUserSuggestion = await fetchReadOnlyUserSuggestion();+ setPrivileges(readOnlyUserSuggestion?.privileges || []);- const isReadOnly = await checkReadOnlyUser();- if (isReadOnly) {- onAlreadyExists();+ // A failed check must not silently advance the wizard - keep the screen so the user+ // still gets the choice.+ if (readOnlyUserSuggestion && !readOnlyUserSuggestion.shouldSuggestReadOnlyUser) {+ onReadOnlyUserNotSuggested();}- setIsCheckingReadOnlyUser(false);+ setIsCheckingReadOnlyUserSuggestion(false);};run();}, []);- if (isCheckingReadOnlyUser) {+ if (isCheckingReadOnlyUserSuggestion) {return (<div className="flex items-center"><Spin />diff --git a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsxindex 0512c4a1..3d4964f1 100644--- a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx+++ b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx@@ -1,4 +1,4 @@-import { Modal } from 'antd';+import { App, Modal } from 'antd';import { useState } from 'react';import { type Database, DatabaseType, databaseApi } from '../../../../entity/databases';@@ -44,6 +44,8 @@ export const EditDatabaseSpecificDataComponent = ({isRestoreMode = false,onConnectionErrorChange,}: Props) => {+ const { message } = App.useApp();+const [isShowReadOnlyDialog, setIsShowReadOnlyDialog] = useState(false);const [editingDatabase, setEditingDatabase] = useState<Database>(database);@@ -56,15 +58,15 @@ export const EditDatabaseSpecificDataComponent = ({}try {- const result = await databaseApi.isUserReadOnly(databaseToSave);+ const readOnlyUserSuggestion = await databaseApi.shouldSuggestReadOnlyUser(databaseToSave);- if (result.isReadOnly) {- onSaved(databaseToSave);- } else {+ if (readOnlyUserSuggestion.shouldSuggestReadOnlyUser) {setIsShowReadOnlyDialog(true);+ } else {+ onSaved(databaseToSave);}} catch (e) {- alert((e as Error).message);+ message.error((e as Error).message);}};@@ -100,8 +102,7 @@ export const EditDatabaseSpecificDataComponent = ({onSkipped={() => {skipReadOnlyUser();}}- onAlreadyExists={() => {- console.log('onAlreadyExists');+ onReadOnlyUserNotSuggested={() => {onSaved(editingDatabase);}}/>