Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

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.go
index 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,
+ })
}
// CreateReadOnlyUser
diff --git a/backend/internal/features/databases/databases/mariadb/model.go b/backend/internal/features/databases/databases/mariadb/model.go
index 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.go
index 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 string
version tools.MariadbVersion
image 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.go
index 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 role
for _, 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.go
index 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.go
index 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.go
index 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.go
index 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 transaction
func (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 bool
err = 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 collision
maxRetries := 3
for 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.1
return 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.go
index 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.Endpo
assert.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, ver
logger := 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.En
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, "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 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, "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 *te
assert.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.go
index 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 exactly
diff --git a/backend/internal/features/databases/databases/postgresql/physical/model_test.go b/backend/internal/features/databases/databases/postgresql/physical/model_test.go
index 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 = username
m.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 = username
m.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 *te
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, "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.go
index 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.go
index 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.go
index 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) error
return 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.go
index 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.Username
physical.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.ts
index 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.ts
index 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.ts
deleted file mode 100644
index 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.ts
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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);
}}
/>