Skip to content

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

FEATURE (protection): Do not expose sensetive data of databases, notifiers and storages from API + make backups lazy loaded

Rostislav Dugina809dc8a9c1d
diff --git a/backend/internal/features/backups/backups/controller.go b/backend/internal/features/backups/backups/controller.go
index 20f09fb6..9718b992 100644
--- a/backend/internal/features/backups/backups/controller.go
+++ b/backend/internal/features/backups/backups/controller.go
@@ -23,11 +23,13 @@ func (c *BackupController) RegisterRoutes(router *gin.RouterGroup) {
// GetBackups
// @Summary Get backups for a database
-// @Description Get all backups for the specified database
+// @Description Get paginated backups for the specified database
// @Tags backups
// @Produce json
// @Param database_id query string true "Database ID"
-// @Success 200 {array} Backup
+// @Param limit query int false "Number of items per page" default(10)
+// @Param offset query int false "Offset for pagination" default(0)
+// @Success 200 {object} GetBackupsResponse
// @Failure 400
// @Failure 401
// @Failure 500
@@ -39,25 +41,25 @@ func (c *BackupController) GetBackups(ctx *gin.Context) {
return
}
- databaseIDStr := ctx.Query("database_id")
- if databaseIDStr == "" {
- ctx.JSON(http.StatusBadRequest, gin.H{"error": "database_id query parameter is required"})
+ var request GetBackupsRequest
+ if err := ctx.ShouldBindQuery(&request); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
- databaseID, err := uuid.Parse(databaseIDStr)
+ databaseID, err := uuid.Parse(request.DatabaseID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid database_id"})
return
}
- backups, err := c.backupService.GetBackups(user, databaseID)
+ response, err := c.backupService.GetBackups(user, databaseID, request.Limit, request.Offset)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
- ctx.JSON(http.StatusOK, backups)
+ ctx.JSON(http.StatusOK, response)
}
// MakeBackup
diff --git a/backend/internal/features/backups/backups/controller_test.go b/backend/internal/features/backups/backups/controller_test.go
index d16d49a0..8c6c9c3a 100644
--- a/backend/internal/features/backups/backups/controller_test.go
+++ b/backend/internal/features/backups/backups/controller_test.go
@@ -102,10 +102,11 @@ func Test_GetBackups_PermissionsEnforced(t *testing.T) {
)
if tt.expectSuccess {
- var backups []*Backup
- err := json.Unmarshal(testResp.Body, &backups)
+ var response GetBackupsResponse
+ err := json.Unmarshal(testResp.Body, &response)
assert.NoError(t, err)
- assert.GreaterOrEqual(t, len(backups), 1)
+ assert.GreaterOrEqual(t, len(response.Backups), 1)
+ assert.GreaterOrEqual(t, response.Total, int64(1))
} else {
assert.Contains(t, string(testResp.Body), "insufficient permissions")
}
@@ -329,9 +330,9 @@ func Test_DeleteBackup_PermissionsEnforced(t *testing.T) {
ownerUser, err := userService.GetUserFromToken(owner.Token)
assert.NoError(t, err)
- backups, err := GetBackupService().GetBackups(ownerUser, database.ID)
+ response, err := GetBackupService().GetBackups(ownerUser, database.ID, 10, 0)
assert.NoError(t, err)
- assert.Equal(t, 0, len(backups))
+ assert.Equal(t, 0, len(response.Backups))
}
})
}
diff --git a/backend/internal/features/backups/backups/dto.go b/backend/internal/features/backups/backups/dto.go
new file mode 100644
index 00000000..92d5c029
--- /dev/null
+++ b/backend/internal/features/backups/backups/dto.go
@@ -0,0 +1,14 @@
+package backups
+
+type GetBackupsRequest struct {
+ DatabaseID string `form:"database_id" binding:"required"`
+ Limit int `form:"limit"`
+ Offset int `form:"offset"`
+}
+
+type GetBackupsResponse struct {
+ Backups []*Backup `json:"backups"`
+ Total int64 `json:"total"`
+ Limit int `json:"limit"`
+ Offset int `json:"offset"`
+}
diff --git a/backend/internal/features/backups/backups/repository.go b/backend/internal/features/backups/backups/repository.go
index 2cc8a746..a9e44fd0 100644
--- a/backend/internal/features/backups/backups/repository.go
+++ b/backend/internal/features/backups/backups/repository.go
@@ -195,3 +195,38 @@ func (r *BackupRepository) FindBackupsBeforeDate(
return backups, nil
}
+
+func (r *BackupRepository) FindByDatabaseIDWithPagination(
+ databaseID uuid.UUID,
+ limit, offset int,
+) ([]*Backup, error) {
+ var backups []*Backup
+
+ if err := storage.
+ GetDb().
+ Preload("Database").
+ Preload("Storage").
+ Where("database_id = ?", databaseID).
+ Order("created_at DESC").
+ Limit(limit).
+ Offset(offset).
+ Find(&backups).Error; err != nil {
+ return nil, err
+ }
+
+ return backups, nil
+}
+
+func (r *BackupRepository) CountByDatabaseID(databaseID uuid.UUID) (int64, error) {
+ var count int64
+
+ if err := storage.
+ GetDb().
+ Model(&Backup{}).
+ Where("database_id = ?", databaseID).
+ Count(&count).Error; err != nil {
+ return 0, err
+ }
+
+ return count, nil
+}
diff --git a/backend/internal/features/backups/backups/service.go b/backend/internal/features/backups/backups/service.go
index c7f59c5f..5a4db7e5 100644
--- a/backend/internal/features/backups/backups/service.go
+++ b/backend/internal/features/backups/backups/service.go
@@ -93,7 +93,8 @@ func (s *BackupService) MakeBackupWithAuth(
func (s *BackupService) GetBackups(
user *users_models.User,
databaseID uuid.UUID,
-) ([]*Backup, error) {
+ limit, offset int,
+) (*GetBackupsResponse, error) {
database, err := s.databaseService.GetDatabaseByID(databaseID)
if err != nil {
return nil, err
@@ -111,12 +112,29 @@ func (s *BackupService) GetBackups(
return nil, errors.New("insufficient permissions to access backups for this database")
}
- backups, err := s.backupRepository.FindByDatabaseID(databaseID)
+ if limit <= 0 {
+ limit = 10
+ }
+ if offset < 0 {
+ offset = 0
+ }
+
+ backups, err := s.backupRepository.FindByDatabaseIDWithPagination(databaseID, limit, offset)
+ if err != nil {
+ return nil, err
+ }
+
+ total, err := s.backupRepository.CountByDatabaseID(databaseID)
if err != nil {
return nil, err
}
- return backups, nil
+ return &GetBackupsResponse{
+ Backups: backups,
+ Total: total,
+ Limit: limit,
+ Offset: offset,
+ }, nil
}
func (s *BackupService) DeleteBackup(
diff --git a/backend/internal/features/backups/config/service.go b/backend/internal/features/backups/config/service.go
index 458d0a1a..80d52f38 100644
--- a/backend/internal/features/backups/config/service.go
+++ b/backend/internal/features/backups/config/service.go
@@ -82,19 +82,6 @@ func (s *BackupConfigService) SaveBackupConfig(
}
}
- if !backupConfig.IsBackupsEnabled && existingConfig.StorageID != nil {
- if err := s.dbStorageChangeListener.OnBeforeBackupsStorageChange(
- backupConfig.DatabaseID,
- ); err != nil {
- return nil, err
- }
-
- // we clear storage for disabled backups to allow
- // storage removal for unused storages
- backupConfig.Storage = nil
- backupConfig.StorageID = nil
- }
-
return s.backupConfigRepository.Save(backupConfig)
}
diff --git a/backend/internal/features/databases/controller_test.go b/backend/internal/features/databases/controller_test.go
index 8457edaa..f67f1052 100644
--- a/backend/internal/features/databases/controller_test.go
+++ b/backend/internal/features/databases/controller_test.go
@@ -768,3 +768,161 @@ func createTestDatabaseViaAPI(
return &database
}
+
+func Test_DatabaseSensitiveDataLifecycle_AllTypes(t *testing.T) {
+ testCases := []struct {
+ name string
+ databaseType DatabaseType
+ createDatabase func(workspaceID uuid.UUID) *Database
+ updateDatabase func(workspaceID uuid.UUID, databaseID uuid.UUID) *Database
+ verifySensitiveData func(t *testing.T, database *Database)
+ verifyHiddenData func(t *testing.T, database *Database)
+ }{
+ {
+ name: "PostgreSQL Database",
+ databaseType: DatabaseTypePostgres,
+ createDatabase: func(workspaceID uuid.UUID) *Database {
+ testDbName := "test_db"
+ return &Database{
+ WorkspaceID: &workspaceID,
+ Name: "Test PostgreSQL Database",
+ Type: DatabaseTypePostgres,
+ Postgresql: &postgresql.PostgresqlDatabase{
+ Version: tools.PostgresqlVersion16,
+ Host: "localhost",
+ Port: 5432,
+ Username: "postgres",
+ Password: "original-password-secret",
+ Database: &testDbName,
+ },
+ }
+ },
+ updateDatabase: func(workspaceID uuid.UUID, databaseID uuid.UUID) *Database {
+ testDbName := "updated_test_db"
+ return &Database{
+ ID: databaseID,
+ WorkspaceID: &workspaceID,
+ Name: "Updated PostgreSQL Database",
+ Type: DatabaseTypePostgres,
+ Postgresql: &postgresql.PostgresqlDatabase{
+ Version: tools.PostgresqlVersion17,
+ Host: "updated-host",
+ Port: 5433,
+ Username: "updated_user",
+ Password: "",
+ Database: &testDbName,
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, database *Database) {
+ assert.Equal(t, "original-password-secret", database.Postgresql.Password)
+ },
+ verifyHiddenData: func(t *testing.T, database *Database) {
+ assert.Equal(t, "", database.Postgresql.Password)
+ },
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ router := createTestRouter()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ // Phase 1: Create database with sensitive data
+ initialDatabase := tc.createDatabase(workspace.ID)
+ var createdDatabase Database
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/create",
+ "Bearer "+owner.Token,
+ *initialDatabase,
+ http.StatusCreated,
+ &createdDatabase,
+ )
+ assert.NotEmpty(t, createdDatabase.ID)
+ assert.Equal(t, initialDatabase.Name, createdDatabase.Name)
+
+ // Phase 2: Read via service - sensitive data should be hidden
+ var retrievedDatabase Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/databases/%s", createdDatabase.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ tc.verifyHiddenData(t, &retrievedDatabase)
+ assert.Equal(t, initialDatabase.Name, retrievedDatabase.Name)
+
+ // Phase 3: Update with non-sensitive changes only (sensitive fields empty)
+ updatedDatabase := tc.updateDatabase(workspace.ID, createdDatabase.ID)
+ var updateResponse Database
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ *updatedDatabase,
+ http.StatusOK,
+ &updateResponse,
+ )
+
+ // Phase 4: Retrieve directly from repository to verify sensitive data preservation
+ repository := &DatabaseRepository{}
+ databaseFromDB, err := repository.FindByID(createdDatabase.ID)
+ assert.NoError(t, err)
+
+ // Verify original sensitive data is still present in DB
+ tc.verifySensitiveData(t, databaseFromDB)
+
+ // Verify non-sensitive fields were updated in DB
+ assert.Equal(t, updatedDatabase.Name, databaseFromDB.Name)
+
+ // Phase 5: Additional verification - Check via GET that data is still hidden
+ var finalRetrieved Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/databases/%s", createdDatabase.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &finalRetrieved,
+ )
+ tc.verifyHiddenData(t, &finalRetrieved)
+
+ // Phase 6: Verify GetDatabasesByWorkspace also hides sensitive data
+ var workspaceDatabases []Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/databases?workspace_id=%s", workspace.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &workspaceDatabases,
+ )
+ var foundDatabase *Database
+ for i := range workspaceDatabases {
+ if workspaceDatabases[i].ID == createdDatabase.ID {
+ foundDatabase = &workspaceDatabases[i]
+ break
+ }
+ }
+ assert.NotNil(t, foundDatabase, "Database should be found in workspace databases list")
+ tc.verifyHiddenData(t, foundDatabase)
+
+ // Clean up: Delete database before removing workspace
+ test_utils.MakeDeleteRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/databases/%s", createdDatabase.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusNoContent,
+ )
+
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ })
+ }
+}
diff --git a/backend/internal/features/databases/databases/postgresql/model.go b/backend/internal/features/databases/databases/postgresql/model.go
index 4511ddf4..954d0d19 100644
--- a/backend/internal/features/databases/databases/postgresql/model.go
+++ b/backend/internal/features/databases/databases/postgresql/model.go
@@ -66,6 +66,23 @@ func (p *PostgresqlDatabase) TestConnection(logger *slog.Logger) error {
return testSingleDatabaseConnection(logger, ctx, p)
}
+func (p *PostgresqlDatabase) HideSensitiveData() {
+ p.Password = ""
+}
+
+func (p *PostgresqlDatabase) Update(incoming *PostgresqlDatabase) {
+ p.Version = incoming.Version
+ p.Host = incoming.Host
+ p.Port = incoming.Port
+ p.Username = incoming.Username
+ p.Database = incoming.Database
+ p.IsHttps = incoming.IsHttps
+
+ if incoming.Password != "" {
+ p.Password = incoming.Password
+ }
+}
+
// testSingleDatabaseConnection tests connection to a specific database for pg_dump
func testSingleDatabaseConnection(
logger *slog.Logger,
diff --git a/backend/internal/features/databases/interfaces.go b/backend/internal/features/databases/interfaces.go
index f0eb7f61..21f859b4 100644
--- a/backend/internal/features/databases/interfaces.go
+++ b/backend/internal/features/databases/interfaces.go
@@ -12,6 +12,8 @@ type DatabaseValidator interface {
type DatabaseConnector interface {
TestConnection(logger *slog.Logger) error
+
+ HideSensitiveData()
}
type DatabaseCreationListener interface {
diff --git a/backend/internal/features/databases/model.go b/backend/internal/features/databases/model.go
index f21a12fc..7735de4d 100644
--- a/backend/internal/features/databases/model.go
+++ b/backend/internal/features/databases/model.go
@@ -60,6 +60,22 @@ func (d *Database) TestConnection(logger *slog.Logger) error {
return d.getSpecificDatabase().TestConnection(logger)
}
+func (d *Database) HideSensitiveData() {
+ d.getSpecificDatabase().HideSensitiveData()
+}
+
+func (d *Database) Update(incoming *Database) {
+ d.Name = incoming.Name
+ d.Type = incoming.Type
+
+ switch d.Type {
+ case DatabaseTypePostgres:
+ if d.Postgresql != nil && incoming.Postgresql != nil {
+ d.Postgresql.Update(incoming.Postgresql)
+ }
+ }
+}
+
func (d *Database) getSpecificDatabase() DatabaseConnector {
switch d.Type {
case DatabaseTypePostgres:
diff --git a/backend/internal/features/databases/service.go b/backend/internal/features/databases/service.go
index 37f8ef99..215c0ef9 100644
--- a/backend/internal/features/databases/service.go
+++ b/backend/internal/features/databases/service.go
@@ -112,17 +112,19 @@ func (s *DatabaseService) UpdateDatabase(
return err
}
- if err := database.Validate(); err != nil {
+ existingDatabase.Update(database)
+
+ if err := existingDatabase.Validate(); err != nil {
return err
}
- _, err = s.dbRepository.Save(database)
+ _, err = s.dbRepository.Save(existingDatabase)
if err != nil {
return err
}
s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database updated: %s", database.Name),
+ fmt.Sprintf("Database updated: %s", existingDatabase.Name),
&user.ID,
existingDatabase.WorkspaceID,
)
@@ -187,6 +189,7 @@ func (s *DatabaseService) GetDatabase(
return nil, errors.New("insufficient permissions to access this database")
}
+ database.HideSensitiveData()
return database, nil
}
@@ -202,7 +205,16 @@ func (s *DatabaseService) GetDatabasesByWorkspace(
return nil, errors.New("insufficient permissions to access this workspace")
}
- return s.dbRepository.FindByWorkspaceID(workspaceID)
+ databases, err := s.dbRepository.FindByWorkspaceID(workspaceID)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, database := range databases {
+ database.HideSensitiveData()
+ }
+
+ return databases, nil
}
func (s *DatabaseService) IsNotifierUsing(
@@ -259,7 +271,31 @@ func (s *DatabaseService) TestDatabaseConnection(
func (s *DatabaseService) TestDatabaseConnectionDirect(
database *Database,
) error {
- return database.TestConnection(s.logger)
+ var usingDatabase *Database
+
+ if database.ID != uuid.Nil {
+ existingDatabase, err := s.dbRepository.FindByID(database.ID)
+ if err != nil {
+ return err
+ }
+
+ if database.WorkspaceID != nil && existingDatabase.WorkspaceID != nil &&
+ *existingDatabase.WorkspaceID != *database.WorkspaceID {
+ return errors.New("database does not belong to this workspace")
+ }
+
+ existingDatabase.Update(database)
+
+ if err := existingDatabase.Validate(); err != nil {
+ return err
+ }
+
+ usingDatabase = existingDatabase
+ } else {
+ usingDatabase = database
+ }
+
+ return usingDatabase.TestConnection(s.logger)
}
func (s *DatabaseService) GetDatabaseByID(
diff --git a/backend/internal/features/notifiers/controller.go b/backend/internal/features/notifiers/controller.go
index 576e4830..2169867e 100644
--- a/backend/internal/features/notifiers/controller.go
+++ b/backend/internal/features/notifiers/controller.go
@@ -54,11 +54,6 @@ func (c *NotifierController) SaveNotifier(ctx *gin.Context) {
return
}
- if err := request.Validate(); err != nil {
- ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
- return
- }
-
if err := c.notifierService.SaveNotifier(user, request.WorkspaceID, &request); err != nil {
if err.Error() == "insufficient permissions to manage notifier in this workspace" {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
diff --git a/backend/internal/features/notifiers/controller_test.go b/backend/internal/features/notifiers/controller_test.go
index e2441afd..85b09daf 100644
--- a/backend/internal/features/notifiers/controller_test.go
+++ b/backend/internal/features/notifiers/controller_test.go
@@ -7,6 +7,10 @@ import (
"postgresus-backend/internal/config"
audit_logs "postgresus-backend/internal/features/audit_logs"
+ discord_notifier "postgresus-backend/internal/features/notifiers/models/discord"
+ email_notifier "postgresus-backend/internal/features/notifiers/models/email_notifier"
+ slack_notifier "postgresus-backend/internal/features/notifiers/models/slack"
+ teams_notifier "postgresus-backend/internal/features/notifiers/models/teams"
telegram_notifier "postgresus-backend/internal/features/notifiers/models/telegram"
webhook_notifier "postgresus-backend/internal/features/notifiers/models/webhook"
users_enums "postgresus-backend/internal/features/users/enums"
@@ -512,3 +516,300 @@ func deleteNotifier(
http.StatusOK,
)
}
+
+func Test_NotifierSensitiveDataLifecycle_AllTypes(t *testing.T) {
+ testCases := []struct {
+ name string
+ notifierType NotifierType
+ createNotifier func(workspaceID uuid.UUID) *Notifier
+ updateNotifier func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier
+ verifySensitiveData func(t *testing.T, notifier *Notifier)
+ verifyHiddenData func(t *testing.T, notifier *Notifier)
+ }{
+ {
+ name: "Telegram Notifier",
+ notifierType: NotifierTypeTelegram,
+ createNotifier: func(workspaceID uuid.UUID) *Notifier {
+ return &Notifier{
+ WorkspaceID: workspaceID,
+ Name: "Test Telegram Notifier",
+ NotifierType: NotifierTypeTelegram,
+ TelegramNotifier: &telegram_notifier.TelegramNotifier{
+ BotToken: "original-bot-token-12345",
+ TargetChatID: "123456789",
+ },
+ }
+ },
+ updateNotifier: func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier {
+ return &Notifier{
+ ID: notifierID,
+ WorkspaceID: workspaceID,
+ Name: "Updated Telegram Notifier",
+ NotifierType: NotifierTypeTelegram,
+ TelegramNotifier: &telegram_notifier.TelegramNotifier{
+ BotToken: "",
+ TargetChatID: "987654321",
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "original-bot-token-12345", notifier.TelegramNotifier.BotToken)
+ },
+ verifyHiddenData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "", notifier.TelegramNotifier.BotToken)
+ },
+ },
+ {
+ name: "Email Notifier",
+ notifierType: NotifierTypeEmail,
+ createNotifier: func(workspaceID uuid.UUID) *Notifier {
+ return &Notifier{
+ WorkspaceID: workspaceID,
+ Name: "Test Email Notifier",
+ NotifierType: NotifierTypeEmail,
+ EmailNotifier: &email_notifier.EmailNotifier{
+ TargetEmail: "[email protected]",
+ SMTPHost: "smtp.example.com",
+ SMTPPort: 587,
+ SMTPUser: "[email protected]",
+ SMTPPassword: "original-password-secret",
+ },
+ }
+ },
+ updateNotifier: func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier {
+ return &Notifier{
+ ID: notifierID,
+ WorkspaceID: workspaceID,
+ Name: "Updated Email Notifier",
+ NotifierType: NotifierTypeEmail,
+ EmailNotifier: &email_notifier.EmailNotifier{
+ TargetEmail: "[email protected]",
+ SMTPHost: "smtp.newhost.com",
+ SMTPPort: 465,
+ SMTPUser: "[email protected]",
+ SMTPPassword: "",
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "original-password-secret", notifier.EmailNotifier.SMTPPassword)
+ },
+ verifyHiddenData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "", notifier.EmailNotifier.SMTPPassword)
+ },
+ },
+ {
+ name: "Slack Notifier",
+ notifierType: NotifierTypeSlack,
+ createNotifier: func(workspaceID uuid.UUID) *Notifier {
+ return &Notifier{
+ WorkspaceID: workspaceID,
+ Name: "Test Slack Notifier",
+ NotifierType: NotifierTypeSlack,
+ SlackNotifier: &slack_notifier.SlackNotifier{
+ BotToken: "xoxb-original-slack-token",
+ TargetChatID: "C123456",
+ },
+ }
+ },
+ updateNotifier: func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier {
+ return &Notifier{
+ ID: notifierID,
+ WorkspaceID: workspaceID,
+ Name: "Updated Slack Notifier",
+ NotifierType: NotifierTypeSlack,
+ SlackNotifier: &slack_notifier.SlackNotifier{
+ BotToken: "",
+ TargetChatID: "C789012",
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "xoxb-original-slack-token", notifier.SlackNotifier.BotToken)
+ },
+ verifyHiddenData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "", notifier.SlackNotifier.BotToken)
+ },
+ },
+ {
+ name: "Discord Notifier",
+ notifierType: NotifierTypeDiscord,
+ createNotifier: func(workspaceID uuid.UUID) *Notifier {
+ return &Notifier{
+ WorkspaceID: workspaceID,
+ Name: "Test Discord Notifier",
+ NotifierType: NotifierTypeDiscord,
+ DiscordNotifier: &discord_notifier.DiscordNotifier{
+ ChannelWebhookURL: "https://discord.com/api/webhooks/123/original-token",
+ },
+ }
+ },
+ updateNotifier: func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier {
+ return &Notifier{
+ ID: notifierID,
+ WorkspaceID: workspaceID,
+ Name: "Updated Discord Notifier",
+ NotifierType: NotifierTypeDiscord,
+ DiscordNotifier: &discord_notifier.DiscordNotifier{
+ ChannelWebhookURL: "",
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(
+ t,
+ "https://discord.com/api/webhooks/123/original-token",
+ notifier.DiscordNotifier.ChannelWebhookURL,
+ )
+ },
+ verifyHiddenData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "", notifier.DiscordNotifier.ChannelWebhookURL)
+ },
+ },
+ {
+ name: "Teams Notifier",
+ notifierType: NotifierTypeTeams,
+ createNotifier: func(workspaceID uuid.UUID) *Notifier {
+ return &Notifier{
+ WorkspaceID: workspaceID,
+ Name: "Test Teams Notifier",
+ NotifierType: NotifierTypeTeams,
+ TeamsNotifier: &teams_notifier.TeamsNotifier{
+ WebhookURL: "https://outlook.office.com/webhook/original-token",
+ },
+ }
+ },
+ updateNotifier: func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier {
+ return &Notifier{
+ ID: notifierID,
+ WorkspaceID: workspaceID,
+ Name: "Updated Teams Notifier",
+ NotifierType: NotifierTypeTeams,
+ TeamsNotifier: &teams_notifier.TeamsNotifier{
+ WebhookURL: "",
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(
+ t,
+ "https://outlook.office.com/webhook/original-token",
+ notifier.TeamsNotifier.WebhookURL,
+ )
+ },
+ verifyHiddenData: func(t *testing.T, notifier *Notifier) {
+ assert.Equal(t, "", notifier.TeamsNotifier.WebhookURL)
+ },
+ },
+ {
+ name: "Webhook Notifier",
+ notifierType: NotifierTypeWebhook,
+ createNotifier: func(workspaceID uuid.UUID) *Notifier {
+ return &Notifier{
+ WorkspaceID: workspaceID,
+ Name: "Test Webhook Notifier",
+ NotifierType: NotifierTypeWebhook,
+ WebhookNotifier: &webhook_notifier.WebhookNotifier{
+ WebhookURL: "https://webhook.example.com/test",
+ WebhookMethod: webhook_notifier.WebhookMethodPOST,
+ },
+ }
+ },
+ updateNotifier: func(workspaceID uuid.UUID, notifierID uuid.UUID) *Notifier {
+ return &Notifier{
+ ID: notifierID,
+ WorkspaceID: workspaceID,
+ Name: "Updated Webhook Notifier",
+ NotifierType: NotifierTypeWebhook,
+ WebhookNotifier: &webhook_notifier.WebhookNotifier{
+ WebhookURL: "https://webhook.example.com/updated",
+ WebhookMethod: webhook_notifier.WebhookMethodGET,
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, notifier *Notifier) {
+ // No sensitive data to verify for webhook
+ },
+ verifyHiddenData: func(t *testing.T, notifier *Notifier) {
+ // No sensitive data to hide for webhook
+ },
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ router := createRouter()
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ // Phase 1: Create notifier with sensitive data
+ initialNotifier := tc.createNotifier(workspace.ID)
+ var createdNotifier Notifier
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers",
+ "Bearer "+owner.Token,
+ *initialNotifier,
+ http.StatusOK,
+ &createdNotifier,
+ )
+ assert.NotEmpty(t, createdNotifier.ID)
+ assert.Equal(t, initialNotifier.Name, createdNotifier.Name)
+
+ // Phase 2: Read via service - sensitive data should be hidden
+ var retrievedNotifier Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s", createdNotifier.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedNotifier,
+ )
+ tc.verifyHiddenData(t, &retrievedNotifier)
+ assert.Equal(t, initialNotifier.Name, retrievedNotifier.Name)
+
+ // Phase 3: Update with non-sensitive changes only (sensitive fields empty)
+ updatedNotifier := tc.updateNotifier(workspace.ID, createdNotifier.ID)
+ var updateResponse Notifier
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers",
+ "Bearer "+owner.Token,
+ *updatedNotifier,
+ http.StatusOK,
+ &updateResponse,
+ )
+ // Verify non-sensitive fields were updated
+ assert.Equal(t, updatedNotifier.Name, updateResponse.Name)
+
+ // Phase 4: Retrieve directly from repository to verify sensitive data preservation
+ repository := &NotifierRepository{}
+ notifierFromDB, err := repository.FindByID(createdNotifier.ID)
+ assert.NoError(t, err)
+
+ // Verify original sensitive data is still present in DB
+ tc.verifySensitiveData(t, notifierFromDB)
+
+ // Verify non-sensitive fields were updated in DB
+ assert.Equal(t, updatedNotifier.Name, notifierFromDB.Name)
+
+ // Phase 5: Additional verification - Check via GET that data is still hidden
+ var finalRetrieved Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s", createdNotifier.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &finalRetrieved,
+ )
+ tc.verifyHiddenData(t, &finalRetrieved)
+
+ deleteNotifier(t, router, createdNotifier.ID, workspace.ID, owner.Token)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ })
+ }
+}
diff --git a/backend/internal/features/notifiers/interfaces.go b/backend/internal/features/notifiers/interfaces.go
index f1dfa395..f5ff00ff 100644
--- a/backend/internal/features/notifiers/interfaces.go
+++ b/backend/internal/features/notifiers/interfaces.go
@@ -6,4 +6,6 @@ type NotificationSender interface {
Send(logger *slog.Logger, heading string, message string) error
Validate() error
+
+ HideSensitiveData()
}
diff --git a/backend/internal/features/notifiers/model.go b/backend/internal/features/notifiers/model.go
index 01457900..5db5b30b 100644
--- a/backend/internal/features/notifiers/model.go
+++ b/backend/internal/features/notifiers/model.go
@@ -54,6 +54,42 @@ func (n *Notifier) Send(logger *slog.Logger, heading string, message string) err
return err
}
+func (n *Notifier) HideSensitiveData() {
+ n.getSpecificNotifier().HideSensitiveData()
+}
+
+func (n *Notifier) Update(incoming *Notifier) {
+ n.Name = incoming.Name
+ n.NotifierType = incoming.NotifierType
+
+ switch n.NotifierType {
+ case NotifierTypeTelegram:
+ if n.TelegramNotifier != nil && incoming.TelegramNotifier != nil {
+ n.TelegramNotifier.Update(incoming.TelegramNotifier)
+ }
+ case NotifierTypeEmail:
+ if n.EmailNotifier != nil && incoming.EmailNotifier != nil {
+ n.EmailNotifier.Update(incoming.EmailNotifier)
+ }
+ case NotifierTypeWebhook:
+ if n.WebhookNotifier != nil && incoming.WebhookNotifier != nil {
+ n.WebhookNotifier.Update(incoming.WebhookNotifier)
+ }
+ case NotifierTypeSlack:
+ if n.SlackNotifier != nil && incoming.SlackNotifier != nil {
+ n.SlackNotifier.Update(incoming.SlackNotifier)
+ }
+ case NotifierTypeDiscord:
+ if n.DiscordNotifier != nil && incoming.DiscordNotifier != nil {
+ n.DiscordNotifier.Update(incoming.DiscordNotifier)
+ }
+ case NotifierTypeTeams:
+ if n.TeamsNotifier != nil && incoming.TeamsNotifier != nil {
+ n.TeamsNotifier.Update(incoming.TeamsNotifier)
+ }
+ }
+}
+
func (n *Notifier) getSpecificNotifier() NotificationSender {
switch n.NotifierType {
case NotifierTypeTelegram:
diff --git a/backend/internal/features/notifiers/models/discord/model.go b/backend/internal/features/notifiers/models/discord/model.go
index 6ebecb96..85b1c233 100644
--- a/backend/internal/features/notifiers/models/discord/model.go
+++ b/backend/internal/features/notifiers/models/discord/model.go
@@ -71,3 +71,13 @@ func (d *DiscordNotifier) Send(logger *slog.Logger, heading string, message stri
return nil
}
+
+func (d *DiscordNotifier) HideSensitiveData() {
+ d.ChannelWebhookURL = ""
+}
+
+func (d *DiscordNotifier) Update(incoming *DiscordNotifier) {
+ if incoming.ChannelWebhookURL != "" {
+ d.ChannelWebhookURL = incoming.ChannelWebhookURL
+ }
+}
diff --git a/backend/internal/features/notifiers/models/email_notifier/model.go b/backend/internal/features/notifiers/models/email_notifier/model.go
index 3dde5794..689ff107 100644
--- a/backend/internal/features/notifiers/models/email_notifier/model.go
+++ b/backend/internal/features/notifiers/models/email_notifier/model.go
@@ -208,3 +208,18 @@ func (e *EmailNotifier) Send(logger *slog.Logger, heading string, message string
return client.Quit()
}
}
+
+func (e *EmailNotifier) HideSensitiveData() {
+ e.SMTPPassword = ""
+}
+
+func (e *EmailNotifier) Update(incoming *EmailNotifier) {
+ e.TargetEmail = incoming.TargetEmail
+ e.SMTPHost = incoming.SMTPHost
+ e.SMTPPort = incoming.SMTPPort
+ e.SMTPUser = incoming.SMTPUser
+
+ if incoming.SMTPPassword != "" {
+ e.SMTPPassword = incoming.SMTPPassword
+ }
+}
diff --git a/backend/internal/features/notifiers/models/slack/model.go b/backend/internal/features/notifiers/models/slack/model.go
index a743a7b0..cefbcf35 100644
--- a/backend/internal/features/notifiers/models/slack/model.go
+++ b/backend/internal/features/notifiers/models/slack/model.go
@@ -132,3 +132,15 @@ func (s *SlackNotifier) Send(logger *slog.Logger, heading, message string) error
return nil
}
}
+
+func (s *SlackNotifier) HideSensitiveData() {
+ s.BotToken = ""
+}
+
+func (s *SlackNotifier) Update(incoming *SlackNotifier) {
+ s.TargetChatID = incoming.TargetChatID
+
+ if incoming.BotToken != "" {
+ s.BotToken = incoming.BotToken
+ }
+}
diff --git a/backend/internal/features/notifiers/models/teams/model.go b/backend/internal/features/notifiers/models/teams/model.go
index 88287b2c..e3f35983 100644
--- a/backend/internal/features/notifiers/models/teams/model.go
+++ b/backend/internal/features/notifiers/models/teams/model.go
@@ -94,3 +94,13 @@ func (n *TeamsNotifier) Send(logger *slog.Logger, heading, message string) error
return nil
}
+
+func (n *TeamsNotifier) HideSensitiveData() {
+ n.WebhookURL = ""
+}
+
+func (n *TeamsNotifier) Update(incoming *TeamsNotifier) {
+ if incoming.WebhookURL != "" {
+ n.WebhookURL = incoming.WebhookURL
+ }
+}
diff --git a/backend/internal/features/notifiers/models/telegram/model.go b/backend/internal/features/notifiers/models/telegram/model.go
index 56114078..5eca3238 100644
--- a/backend/internal/features/notifiers/models/telegram/model.go
+++ b/backend/internal/features/notifiers/models/telegram/model.go
@@ -80,3 +80,16 @@ func (t *TelegramNotifier) Send(logger *slog.Logger, heading string, message str
return nil
}
+
+func (t *TelegramNotifier) HideSensitiveData() {
+ t.BotToken = ""
+}
+
+func (t *TelegramNotifier) Update(incoming *TelegramNotifier) {
+ t.TargetChatID = incoming.TargetChatID
+ t.ThreadID = incoming.ThreadID
+
+ if incoming.BotToken != "" {
+ t.BotToken = incoming.BotToken
+ }
+}
diff --git a/backend/internal/features/notifiers/models/webhook/model.go b/backend/internal/features/notifiers/models/webhook/model.go
index a7d19ba9..eefffd05 100644
--- a/backend/internal/features/notifiers/models/webhook/model.go
+++ b/backend/internal/features/notifiers/models/webhook/model.go
@@ -102,3 +102,11 @@ func (t *WebhookNotifier) Send(logger *slog.Logger, heading string, message stri
return fmt.Errorf("unsupported webhook method: %s", t.WebhookMethod)
}
}
+
+func (t *WebhookNotifier) HideSensitiveData() {
+}
+
+func (t *WebhookNotifier) Update(incoming *WebhookNotifier) {
+ t.WebhookURL = incoming.WebhookURL
+ t.WebhookMethod = incoming.WebhookMethod
+}
diff --git a/backend/internal/features/notifiers/service.go b/backend/internal/features/notifiers/service.go
index 1f7f54a8..62b0249c 100644
--- a/backend/internal/features/notifiers/service.go
+++ b/backend/internal/features/notifiers/service.go
@@ -44,23 +44,34 @@ func (s *NotifierService) SaveNotifier(
return errors.New("notifier does not belong to this workspace")
}
- notifier.WorkspaceID = existingNotifier.WorkspaceID
- } else {
- notifier.WorkspaceID = workspaceID
- }
+ existingNotifier.Update(notifier)
- _, err = s.notifierRepository.Save(notifier)
- if err != nil {
- return err
- }
+ if err := existingNotifier.Validate(); err != nil {
+ return err
+ }
+
+ _, err = s.notifierRepository.Save(existingNotifier)
+ if err != nil {
+ return err
+ }
- if isUpdate {
s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Notifier updated: %s", notifier.Name),
+ fmt.Sprintf("Notifier updated: %s", existingNotifier.Name),
&user.ID,
&workspaceID,
)
} else {
+ notifier.WorkspaceID = workspaceID
+
+ if err := notifier.Validate(); err != nil {
+ return err
+ }
+
+ _, err = s.notifierRepository.Save(notifier)
+ if err != nil {
+ return err
+ }
+
s.auditLogService.WriteAuditLog(
fmt.Sprintf("Notifier created: %s", notifier.Name),
&user.ID,
@@ -119,6 +130,7 @@ func (s *NotifierService) GetNotifier(
return nil, errors.New("insufficient permissions to view notifier in this workspace")
}
+ notifier.HideSensitiveData()
return notifier, nil
}
@@ -134,7 +146,16 @@ func (s *NotifierService) GetNotifiers(
return nil, errors.New("insufficient permissions to view notifiers in this workspace")
}
- return s.notifierRepository.FindByWorkspaceID(workspaceID)
+ notifiers, err := s.notifierRepository.FindByWorkspaceID(workspaceID)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, notifier := range notifiers {
+ notifier.HideSensitiveData()
+ }
+
+ return notifiers, nil
}
func (s *NotifierService) SendTestNotification(
@@ -170,7 +191,30 @@ func (s *NotifierService) SendTestNotification(
func (s *NotifierService) SendTestNotificationToNotifier(
notifier *Notifier,
) error {
- return notifier.Send(s.logger, "Test message", "This is a test message")
+ var usingNotifier *Notifier
+
+ if notifier.ID != uuid.Nil {
+ existingNotifier, err := s.notifierRepository.FindByID(notifier.ID)
+ if err != nil {
+ return err
+ }
+
+ if existingNotifier.WorkspaceID != notifier.WorkspaceID {
+ return errors.New("notifier does not belong to this workspace")
+ }
+
+ existingNotifier.Update(notifier)
+
+ if err := existingNotifier.Validate(); err != nil {
+ return err
+ }
+
+ usingNotifier = existingNotifier
+ } else {
+ usingNotifier = notifier
+ }
+
+ return usingNotifier.Send(s.logger, "Test message", "This is a test message")
}
func (s *NotifierService) SendNotification(
diff --git a/backend/internal/features/storages/controller.go b/backend/internal/features/storages/controller.go
index 998106d7..f32b6455 100644
--- a/backend/internal/features/storages/controller.go
+++ b/backend/internal/features/storages/controller.go
@@ -54,11 +54,6 @@ func (c *StorageController) SaveStorage(ctx *gin.Context) {
return
}
- if err := request.Validate(); err != nil {
- ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
- return
- }
-
if err := c.storageService.SaveStorage(user, request.WorkspaceID, &request); err != nil {
if err.Error() == "insufficient permissions to manage storage in this workspace" {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -271,11 +266,6 @@ func (c *StorageController) TestStorageConnectionDirect(ctx *gin.Context) {
return
}
- if err := request.Validate(); err != nil {
- ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
- return
- }
-
if err := c.storageService.TestStorageConnectionDirect(&request); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/storages/controller_test.go b/backend/internal/features/storages/controller_test.go
index e6fb8b99..58ab351e 100644
--- a/backend/internal/features/storages/controller_test.go
+++ b/backend/internal/features/storages/controller_test.go
@@ -7,6 +7,7 @@ import (
audit_logs "postgresus-backend/internal/features/audit_logs"
local_storage "postgresus-backend/internal/features/storages/models/local"
+ s3_storage "postgresus-backend/internal/features/storages/models/s3"
users_enums "postgresus-backend/internal/features/users/enums"
users_middleware "postgresus-backend/internal/features/users/middleware"
users_services "postgresus-backend/internal/features/users/services"
@@ -484,3 +485,158 @@ func deleteStorage(
http.StatusOK,
)
}
+
+func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
+ testCases := []struct {
+ name string
+ storageType StorageType
+ createStorage func(workspaceID uuid.UUID) *Storage
+ updateStorage func(workspaceID uuid.UUID, storageID uuid.UUID) *Storage
+ verifySensitiveData func(t *testing.T, storage *Storage)
+ verifyHiddenData func(t *testing.T, storage *Storage)
+ }{
+ {
+ name: "S3 Storage",
+ storageType: StorageTypeS3,
+ createStorage: func(workspaceID uuid.UUID) *Storage {
+ return &Storage{
+ WorkspaceID: workspaceID,
+ Type: StorageTypeS3,
+ Name: "Test S3 Storage",
+ S3Storage: &s3_storage.S3Storage{
+ S3Bucket: "test-bucket",
+ S3Region: "us-east-1",
+ S3AccessKey: "original-access-key",
+ S3SecretKey: "original-secret-key",
+ S3Endpoint: "https://s3.amazonaws.com",
+ },
+ }
+ },
+ updateStorage: func(workspaceID uuid.UUID, storageID uuid.UUID) *Storage {
+ return &Storage{
+ ID: storageID,
+ WorkspaceID: workspaceID,
+ Type: StorageTypeS3,
+ Name: "Updated S3 Storage",
+ S3Storage: &s3_storage.S3Storage{
+ S3Bucket: "updated-bucket",
+ S3Region: "us-west-2",
+ S3AccessKey: "",
+ S3SecretKey: "",
+ S3Endpoint: "https://s3.us-west-2.amazonaws.com",
+ },
+ }
+ },
+ verifySensitiveData: func(t *testing.T, storage *Storage) {
+ assert.Equal(t, "original-access-key", storage.S3Storage.S3AccessKey)
+ assert.Equal(t, "original-secret-key", storage.S3Storage.S3SecretKey)
+ },
+ verifyHiddenData: func(t *testing.T, storage *Storage) {
+ assert.Equal(t, "", storage.S3Storage.S3AccessKey)
+ assert.Equal(t, "", storage.S3Storage.S3SecretKey)
+ },
+ },
+ {
+ name: "Local Storage",
+ storageType: StorageTypeLocal,
+ createStorage: func(workspaceID uuid.UUID) *Storage {
+ return &Storage{
+ WorkspaceID: workspaceID,
+ Type: StorageTypeLocal,
+ Name: "Test Local Storage",
+ LocalStorage: &local_storage.LocalStorage{},
+ }
+ },
+ updateStorage: func(workspaceID uuid.UUID, storageID uuid.UUID) *Storage {
+ return &Storage{
+ ID: storageID,
+ WorkspaceID: workspaceID,
+ Type: StorageTypeLocal,
+ Name: "Updated Local Storage",
+ LocalStorage: &local_storage.LocalStorage{},
+ }
+ },
+ verifySensitiveData: func(t *testing.T, storage *Storage) {
+ },
+ verifyHiddenData: func(t *testing.T, storage *Storage) {
+ },
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ router := createRouter()
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ // Phase 1: Create storage with sensitive data
+ initialStorage := tc.createStorage(workspace.ID)
+ var createdStorage Storage
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/storages",
+ "Bearer "+owner.Token,
+ *initialStorage,
+ http.StatusOK,
+ &createdStorage,
+ )
+
+ assert.NotEmpty(t, createdStorage.ID)
+ assert.Equal(t, initialStorage.Name, createdStorage.Name)
+
+ // Phase 2: Read via service - sensitive data should be hidden
+ var retrievedStorage Storage
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s", createdStorage.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedStorage,
+ )
+
+ tc.verifyHiddenData(t, &retrievedStorage)
+ assert.Equal(t, initialStorage.Name, retrievedStorage.Name)
+
+ // Phase 3: Update with non-sensitive changes only (sensitive fields empty)
+ updatedStorage := tc.updateStorage(workspace.ID, createdStorage.ID)
+ var updateResponse Storage
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/storages",
+ "Bearer "+owner.Token,
+ *updatedStorage,
+ http.StatusOK,
+ &updateResponse,
+ )
+
+ // Verify non-sensitive fields were updated
+ assert.Equal(t, updatedStorage.Name, updateResponse.Name)
+
+ // Phase 4: Retrieve directly from repository to verify sensitive data preservation
+ repository := &StorageRepository{}
+ storageFromDB, err := repository.FindByID(createdStorage.ID)
+ assert.NoError(t, err)
+
+ // Verify original sensitive data is still present in DB
+ tc.verifySensitiveData(t, storageFromDB)
+
+ // Verify non-sensitive fields were updated in DB
+ assert.Equal(t, updatedStorage.Name, storageFromDB.Name)
+
+ // Additional verification: Check via GET that data is still hidden
+ var finalRetrieved Storage
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s", createdStorage.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &finalRetrieved,
+ )
+ tc.verifyHiddenData(t, &finalRetrieved)
+ })
+ }
+}
diff --git a/backend/internal/features/storages/interfaces.go b/backend/internal/features/storages/interfaces.go
index e2f32a94..25e1f94d 100644
--- a/backend/internal/features/storages/interfaces.go
+++ b/backend/internal/features/storages/interfaces.go
@@ -17,4 +17,6 @@ type StorageFileSaver interface {
Validate() error
TestConnection() error
+
+ HideSensitiveData()
}
diff --git a/backend/internal/features/storages/model.go b/backend/internal/features/storages/model.go
index a7c5105d..c422999f 100644
--- a/backend/internal/features/storages/model.go
+++ b/backend/internal/features/storages/model.go
@@ -63,6 +63,34 @@ func (s *Storage) TestConnection() error {
return s.getSpecificStorage().TestConnection()
}
+func (s *Storage) HideSensitiveData() {
+ s.getSpecificStorage().HideSensitiveData()
+}
+
+func (s *Storage) Update(incoming *Storage) {
+ s.Name = incoming.Name
+ s.Type = incoming.Type
+
+ switch s.Type {
+ case StorageTypeLocal:
+ if s.LocalStorage != nil && incoming.LocalStorage != nil {
+ s.LocalStorage.Update(incoming.LocalStorage)
+ }
+ case StorageTypeS3:
+ if s.S3Storage != nil && incoming.S3Storage != nil {
+ s.S3Storage.Update(incoming.S3Storage)
+ }
+ case StorageTypeGoogleDrive:
+ if s.GoogleDriveStorage != nil && incoming.GoogleDriveStorage != nil {
+ s.GoogleDriveStorage.Update(incoming.GoogleDriveStorage)
+ }
+ case StorageTypeNAS:
+ if s.NASStorage != nil && incoming.NASStorage != nil {
+ s.NASStorage.Update(incoming.NASStorage)
+ }
+ }
+}
+
func (s *Storage) getSpecificStorage() StorageFileSaver {
switch s.Type {
case StorageTypeLocal:
diff --git a/backend/internal/features/storages/models/google_drive/model.go b/backend/internal/features/storages/models/google_drive/model.go
index b0c3ad1a..0ff16e51 100644
--- a/backend/internal/features/storages/models/google_drive/model.go
+++ b/backend/internal/features/storages/models/google_drive/model.go
@@ -191,6 +191,23 @@ func (s *GoogleDriveStorage) TestConnection() error {
})
}
+func (s *GoogleDriveStorage) HideSensitiveData() {
+ s.ClientSecret = ""
+ s.TokenJSON = ""
+}
+
+func (s *GoogleDriveStorage) Update(incoming *GoogleDriveStorage) {
+ s.ClientID = incoming.ClientID
+
+ if incoming.ClientSecret != "" {
+ s.ClientSecret = incoming.ClientSecret
+ }
+
+ if incoming.TokenJSON != "" {
+ s.TokenJSON = incoming.TokenJSON
+ }
+}
+
// withRetryOnAuth executes the provided function with retry logic for authentication errors
func (s *GoogleDriveStorage) withRetryOnAuth(fn func(*drive.Service) error) error {
driveService, err := s.getDriveService()
diff --git a/backend/internal/features/storages/models/local/model.go b/backend/internal/features/storages/models/local/model.go
index c26659c8..4efe3f32 100644
--- a/backend/internal/features/storages/models/local/model.go
+++ b/backend/internal/features/storages/models/local/model.go
@@ -156,3 +156,9 @@ func (l *LocalStorage) TestConnection() error {
return nil
}
+
+func (l *LocalStorage) HideSensitiveData() {
+}
+
+func (l *LocalStorage) Update(incoming *LocalStorage) {
+}
diff --git a/backend/internal/features/storages/models/nas/model.go b/backend/internal/features/storages/models/nas/model.go
index abb3d578..70e025c9 100644
--- a/backend/internal/features/storages/models/nas/model.go
+++ b/backend/internal/features/storages/models/nas/model.go
@@ -251,6 +251,24 @@ func (n *NASStorage) TestConnection() error {
return nil
}
+func (n *NASStorage) HideSensitiveData() {
+ n.Password = ""
+}
+
+func (n *NASStorage) Update(incoming *NASStorage) {
+ n.Host = incoming.Host
+ n.Port = incoming.Port
+ n.Share = incoming.Share
+ n.Username = incoming.Username
+ n.UseSSL = incoming.UseSSL
+ n.Domain = incoming.Domain
+ n.Path = incoming.Path
+
+ if incoming.Password != "" {
+ n.Password = incoming.Password
+ }
+}
+
func (n *NASStorage) createSession() (*smb2.Session, error) {
// Create connection with timeout
conn, err := n.createConnection()
diff --git a/backend/internal/features/storages/models/s3/model.go b/backend/internal/features/storages/models/s3/model.go
index b1e6b9ba..65a6d84e 100644
--- a/backend/internal/features/storages/models/s3/model.go
+++ b/backend/internal/features/storages/models/s3/model.go
@@ -180,6 +180,25 @@ func (s *S3Storage) TestConnection() error {
return nil
}
+func (s *S3Storage) HideSensitiveData() {
+ s.S3AccessKey = ""
+ s.S3SecretKey = ""
+}
+
+func (s *S3Storage) Update(incoming *S3Storage) {
+ s.S3Bucket = incoming.S3Bucket
+ s.S3Region = incoming.S3Region
+ s.S3Endpoint = incoming.S3Endpoint
+
+ if incoming.S3AccessKey != "" {
+ s.S3AccessKey = incoming.S3AccessKey
+ }
+
+ if incoming.S3SecretKey != "" {
+ s.S3SecretKey = incoming.S3SecretKey
+ }
+}
+
func (s *S3Storage) getClient() (*minio.Client, error) {
endpoint := s.S3Endpoint
useSSL := true
diff --git a/backend/internal/features/storages/service.go b/backend/internal/features/storages/service.go
index 396db4bf..7bd84c8f 100644
--- a/backend/internal/features/storages/service.go
+++ b/backend/internal/features/storages/service.go
@@ -42,23 +42,34 @@ func (s *StorageService) SaveStorage(
return errors.New("storage does not belong to this workspace")
}
- storage.WorkspaceID = existingStorage.WorkspaceID
- } else {
- storage.WorkspaceID = workspaceID
- }
+ existingStorage.Update(storage)
- _, err = s.storageRepository.Save(storage)
- if err != nil {
- return err
- }
+ if err := existingStorage.Validate(); err != nil {
+ return err
+ }
+
+ _, err = s.storageRepository.Save(existingStorage)
+ if err != nil {
+ return err
+ }
- if isUpdate {
s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage updated: %s", storage.Name),
+ fmt.Sprintf("Storage updated: %s", existingStorage.Name),
&user.ID,
&workspaceID,
)
} else {
+ storage.WorkspaceID = workspaceID
+
+ if err := storage.Validate(); err != nil {
+ return err
+ }
+
+ _, err = s.storageRepository.Save(storage)
+ if err != nil {
+ return err
+ }
+
s.auditLogService.WriteAuditLog(
fmt.Sprintf("Storage created: %s", storage.Name),
&user.ID,
@@ -117,6 +128,8 @@ func (s *StorageService) GetStorage(
return nil, errors.New("insufficient permissions to view storage in this workspace")
}
+ storage.HideSensitiveData()
+
return storage, nil
}
@@ -132,7 +145,16 @@ func (s *StorageService) GetStorages(
return nil, errors.New("insufficient permissions to view storages in this workspace")
}
- return s.storageRepository.FindByWorkspaceID(workspaceID)
+ storages, err := s.storageRepository.FindByWorkspaceID(workspaceID)
+ if err != nil {
+ return nil, err
+ }
+
+ for _, storage := range storages {
+ storage.HideSensitiveData()
+ }
+
+ return storages, nil
}
func (s *StorageService) TestStorageConnection(
@@ -171,7 +193,30 @@ func (s *StorageService) TestStorageConnection(
func (s *StorageService) TestStorageConnectionDirect(
storage *Storage,
) error {
- return storage.TestConnection()
+ var usingStorage *Storage
+
+ if storage.ID != uuid.Nil {
+ existingStorage, err := s.storageRepository.FindByID(storage.ID)
+ if err != nil {
+ return err
+ }
+
+ if existingStorage.WorkspaceID != storage.WorkspaceID {
+ return errors.New("storage does not belong to this workspace")
+ }
+
+ existingStorage.Update(storage)
+
+ if err := existingStorage.Validate(); err != nil {
+ return err
+ }
+
+ usingStorage = existingStorage
+ } else {
+ usingStorage = storage
+ }
+
+ return usingStorage.TestConnection()
}
func (s *StorageService) GetStorageByID(
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 4afa6b37..0e3c02f5 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -6,6 +6,7 @@ import { Routes } from 'react-router';
import { userApi } from './entity/users';
import { AuthPageComponent } from './pages/AuthPageComponent';
import { OAuthCallbackPage } from './pages/OAuthCallbackPage';
+import { OauthStorageComponent } from './pages/OauthStorageComponent';
import { MainScreenComponent } from './widgets/main/MainScreenComponent';
function App() {
@@ -32,6 +33,7 @@ function App() {
<BrowserRouter>
<Routes>
<Route path="/auth/callback" element={<OAuthCallbackPage />} />
+ <Route path="/storages/google-oauth" element={<OauthStorageComponent />} />
<Route
path="/"
element={!isAuthorized ? <AuthPageComponent /> : <MainScreenComponent />}
diff --git a/frontend/src/entity/backups/api/backupsApi.ts b/frontend/src/entity/backups/api/backupsApi.ts
index 4ce32717..957b5f0e 100644
--- a/frontend/src/entity/backups/api/backupsApi.ts
+++ b/frontend/src/entity/backups/api/backupsApi.ts
@@ -1,12 +1,16 @@
import { getApplicationServer } from '../../../constants';
import RequestOptions from '../../../shared/api/RequestOptions';
import { apiHelper } from '../../../shared/api/apiHelper';
-import type { Backup } from '../model/Backup';
+import type { GetBackupsResponse } from '../model/GetBackupsResponse';
export const backupsApi = {
- async getBackups(databaseId: string) {
- return apiHelper.fetchGetJson<Backup[]>(
- `${getApplicationServer()}/api/v1/backups?database_id=${databaseId}`,
+ async getBackups(databaseId: string, limit?: number, offset?: number) {
+ const params = new URLSearchParams({ database_id: databaseId });
+ if (limit !== undefined) params.append('limit', limit.toString());
+ if (offset !== undefined) params.append('offset', offset.toString());
+
+ return apiHelper.fetchGetJson<GetBackupsResponse>(
+ `${getApplicationServer()}/api/v1/backups?${params.toString()}`,
undefined,
true,
);
diff --git a/frontend/src/entity/backups/model/GetBackupsResponse.ts b/frontend/src/entity/backups/model/GetBackupsResponse.ts
new file mode 100644
index 00000000..5b673849
--- /dev/null
+++ b/frontend/src/entity/backups/model/GetBackupsResponse.ts
@@ -0,0 +1,8 @@
+import type { Backup } from './Backup';
+
+export interface GetBackupsResponse {
+ backups: Backup[];
+ total: number;
+ limit: number;
+ offset: number;
+}
diff --git a/frontend/src/entity/notifiers/models/discord/validateDiscordNotifier.ts b/frontend/src/entity/notifiers/models/discord/validateDiscordNotifier.ts
index b9bdb7ef..29684608 100644
--- a/frontend/src/entity/notifiers/models/discord/validateDiscordNotifier.ts
+++ b/frontend/src/entity/notifiers/models/discord/validateDiscordNotifier.ts
@@ -1,7 +1,7 @@
import type { DiscordNotifier } from './DiscordNotifier';
-export const validateDiscordNotifier = (notifier: DiscordNotifier): boolean => {
- if (!notifier.channelWebhookUrl) {
+export const validateDiscordNotifier = (isCreate: boolean, notifier: DiscordNotifier): boolean => {
+ if (isCreate && !notifier.channelWebhookUrl) {
return false;
}
diff --git a/frontend/src/entity/notifiers/models/email/validateEmailNotifier.ts b/frontend/src/entity/notifiers/models/email/validateEmailNotifier.ts
index b4e99939..9d6c3f72 100644
--- a/frontend/src/entity/notifiers/models/email/validateEmailNotifier.ts
+++ b/frontend/src/entity/notifiers/models/email/validateEmailNotifier.ts
@@ -1,6 +1,6 @@
import type { EmailNotifier } from './EmailNotifier';
-export const validateEmailNotifier = (notifier: EmailNotifier): boolean => {
+export const validateEmailNotifier = (isCreate: boolean, notifier: EmailNotifier): boolean => {
if (!notifier.targetEmail) {
return false;
}
@@ -13,5 +13,9 @@ export const validateEmailNotifier = (notifier: EmailNotifier): boolean => {
return false;
}
+ if (isCreate && !notifier.smtpPassword) {
+ return false;
+ }
+
return true;
};
diff --git a/frontend/src/entity/notifiers/models/slack/validateSlackNotifier.ts b/frontend/src/entity/notifiers/models/slack/validateSlackNotifier.ts
index 63665d8b..fefe22ab 100644
--- a/frontend/src/entity/notifiers/models/slack/validateSlackNotifier.ts
+++ b/frontend/src/entity/notifiers/models/slack/validateSlackNotifier.ts
@@ -1,7 +1,7 @@
import type { SlackNotifier } from './SlackNotifier';
-export const validateSlackNotifier = (notifier: SlackNotifier): boolean => {
- if (!notifier.botToken) {
+export const validateSlackNotifier = (isCreate: boolean, notifier: SlackNotifier): boolean => {
+ if (isCreate && !notifier.botToken) {
return false;
}
diff --git a/frontend/src/entity/notifiers/models/teams/validateTeamsNotifier.ts b/frontend/src/entity/notifiers/models/teams/validateTeamsNotifier.ts
index 28cac0f1..4a1656e8 100644
--- a/frontend/src/entity/notifiers/models/teams/validateTeamsNotifier.ts
+++ b/frontend/src/entity/notifiers/models/teams/validateTeamsNotifier.ts
@@ -1,7 +1,7 @@
import type { TeamsNotifier } from './TeamsNotifier';
-export const validateTeamsNotifier = (notifier: TeamsNotifier): boolean => {
- if (!notifier?.powerAutomateUrl) {
+export const validateTeamsNotifier = (isCreate: boolean, notifier: TeamsNotifier): boolean => {
+ if (isCreate && !notifier?.powerAutomateUrl) {
return false;
}
diff --git a/frontend/src/entity/notifiers/models/telegram/validateTelegramNotifier.ts b/frontend/src/entity/notifiers/models/telegram/validateTelegramNotifier.ts
index f827bd83..2a1a2d3f 100644
--- a/frontend/src/entity/notifiers/models/telegram/validateTelegramNotifier.ts
+++ b/frontend/src/entity/notifiers/models/telegram/validateTelegramNotifier.ts
@@ -1,7 +1,10 @@
import type { TelegramNotifier } from './TelegramNotifier';
-export const validateTelegramNotifier = (notifier: TelegramNotifier): boolean => {
- if (!notifier.botToken) {
+export const validateTelegramNotifier = (
+ isCreate: boolean,
+ notifier: TelegramNotifier,
+): boolean => {
+ if (isCreate && !notifier.botToken) {
return false;
}
diff --git a/frontend/src/entity/notifiers/models/webhook/validateWebhookNotifier.ts b/frontend/src/entity/notifiers/models/webhook/validateWebhookNotifier.ts
index 5d71f74f..a1429b39 100644
--- a/frontend/src/entity/notifiers/models/webhook/validateWebhookNotifier.ts
+++ b/frontend/src/entity/notifiers/models/webhook/validateWebhookNotifier.ts
@@ -1,7 +1,7 @@
import type { WebhookNotifier } from './WebhookNotifier';
-export const validateWebhookNotifier = (notifier: WebhookNotifier): boolean => {
- if (!notifier.webhookUrl) {
+export const validateWebhookNotifier = (isCreate: boolean, notifier: WebhookNotifier): boolean => {
+ if (isCreate && !notifier.webhookUrl) {
return false;
}
diff --git a/frontend/src/features/backups/ui/BackupsComponent.tsx b/frontend/src/features/backups/ui/BackupsComponent.tsx
index e51528c4..19b4f416 100644
--- a/frontend/src/features/backups/ui/BackupsComponent.tsx
+++ b/frontend/src/features/backups/ui/BackupsComponent.tsx
@@ -12,23 +12,37 @@ import type { ColumnsType } from 'antd/es/table';
import dayjs from 'dayjs';
import { useEffect, useRef, useState } from 'react';
-import { type Backup, BackupStatus, backupConfigApi, backupsApi } from '../../../entity/backups';
+import {
+ type Backup,
+ type BackupConfig,
+ BackupStatus,
+ backupConfigApi,
+ backupsApi,
+} from '../../../entity/backups';
import type { Database } from '../../../entity/databases';
import { getUserTimeFormat } from '../../../shared/time';
import { ConfirmationComponent } from '../../../shared/ui';
import { RestoresComponent } from '../../restores';
+const BACKUPS_PAGE_SIZE = 10;
+
interface Props {
database: Database;
isCanManageDBs: boolean;
+ scrollContainerRef?: React.RefObject<HTMLDivElement | null>;
}
-export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
+export const BackupsComponent = ({ database, isCanManageDBs, scrollContainerRef }: Props) => {
const [isBackupsLoading, setIsBackupsLoading] = useState(false);
const [backups, setBackups] = useState<Backup[]>([]);
+ const [totalBackups, setTotalBackups] = useState(0);
+ const [currentLimit, setCurrentLimit] = useState(BACKUPS_PAGE_SIZE);
+ const [isLoadingMore, setIsLoadingMore] = useState(false);
+ const [hasMore, setHasMore] = useState(true);
+
+ const [backupConfig, setBackupConfig] = useState<BackupConfig | undefined>();
const [isBackupConfigLoading, setIsBackupConfigLoading] = useState(false);
- const [isShowBackupConfig, setIsShowBackupConfig] = useState(false);
const [isMakeBackupRequestLoading, setIsMakeBackupRequestLoading] = useState(false);
@@ -40,6 +54,7 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
const [showingRestoresBackupId, setShowingRestoresBackupId] = useState<string | undefined>();
const isReloadInProgress = useRef(false);
+ const isLazyLoadInProgress = useRef(false);
const [downloadingBackupId, setDownloadingBackupId] = useState<string | undefined>();
@@ -71,16 +86,57 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
}
};
- const loadBackups = async () => {
- if (isReloadInProgress.current) {
+ const loadBackups = async (limit?: number) => {
+ if (isReloadInProgress.current || isLazyLoadInProgress.current) {
+ return;
+ }
+
+ isReloadInProgress.current = true;
+
+ try {
+ const loadLimit = limit || currentLimit;
+ const response = await backupsApi.getBackups(database.id, loadLimit, 0);
+
+ setBackups(response.backups);
+ setTotalBackups(response.total);
+ setHasMore(response.backups.length < response.total);
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ isReloadInProgress.current = false;
+ };
+
+ const reloadInProgressBackups = async () => {
+ if (isReloadInProgress.current || isLazyLoadInProgress.current) {
return;
}
isReloadInProgress.current = true;
try {
- const backups = await backupsApi.getBackups(database.id);
- setBackups(backups);
+ // Fetch only the recent backups that could be in progress
+ // We fetch a small number (20) to capture recent backups that might be in progress
+ const response = await backupsApi.getBackups(database.id, 20, 0);
+
+ // Update only the backups that exist in both lists
+ setBackups((prevBackups) => {
+ const updatedBackups = [...prevBackups];
+
+ response.backups.forEach((newBackup) => {
+ const index = updatedBackups.findIndex((b) => b.id === newBackup.id);
+ if (index !== -1) {
+ updatedBackups[index] = newBackup;
+ } else if (index === -1 && updatedBackups.length < currentLimit) {
+ // New backup that doesn't exist yet (e.g., just created)
+ updatedBackups.unshift(newBackup);
+ }
+ });
+
+ return updatedBackups;
+ });
+
+ setTotalBackups(response.total);
} catch (e) {
alert((e as Error).message);
}
@@ -88,12 +144,38 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
isReloadInProgress.current = false;
};
+ const loadMoreBackups = async () => {
+ if (isLoadingMore || !hasMore || isLazyLoadInProgress.current) {
+ return;
+ }
+
+ isLazyLoadInProgress.current = true;
+ setIsLoadingMore(true);
+
+ try {
+ const newLimit = currentLimit + BACKUPS_PAGE_SIZE;
+ const response = await backupsApi.getBackups(database.id, newLimit, 0);
+
+ setBackups(response.backups);
+ setCurrentLimit(newLimit);
+ setTotalBackups(response.total);
+ setHasMore(response.backups.length < response.total);
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsLoadingMore(false);
+ isLazyLoadInProgress.current = false;
+ };
+
const makeBackup = async () => {
setIsMakeBackupRequestLoading(true);
try {
await backupsApi.makeBackup(database.id);
- await loadBackups();
+ setCurrentLimit(BACKUPS_PAGE_SIZE);
+ setHasMore(true);
+ await loadBackups(BACKUPS_PAGE_SIZE);
} catch (e) {
alert((e as Error).message);
}
@@ -111,7 +193,9 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
try {
await backupsApi.deleteBackup(deleteConfimationId);
- await loadBackups();
+ setCurrentLimit(BACKUPS_PAGE_SIZE);
+ setHasMore(true);
+ await loadBackups(BACKUPS_PAGE_SIZE);
} catch (e) {
alert((e as Error).message);
}
@@ -121,30 +205,37 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
};
useEffect(() => {
- let isBackupsEnabled = false;
-
setIsBackupConfigLoading(true);
- backupConfigApi.getBackupConfigByDbID(database.id).then((backupConfig) => {
- setIsBackupConfigLoading(false);
+ setCurrentLimit(BACKUPS_PAGE_SIZE);
+ setHasMore(true);
- if (backupConfig.isBackupsEnabled) {
- // load backups
- isBackupsEnabled = true;
- setIsShowBackupConfig(true);
+ backupConfigApi.getBackupConfigByDbID(database.id).then((config) => {
+ setBackupConfig(config);
+ setIsBackupConfigLoading(false);
- setIsBackupsLoading(true);
- loadBackups().then(() => setIsBackupsLoading(false));
- }
+ setIsBackupsLoading(true);
+ loadBackups(BACKUPS_PAGE_SIZE).then(() => setIsBackupsLoading(false));
});
- const interval = setInterval(() => {
- if (isBackupsEnabled) {
- loadBackups();
- }
+ return () => {};
+ }, [database]);
+
+ // Reload backups that are in progress to update their state
+ useEffect(() => {
+ const hasInProgressBackups = backups.some(
+ (backup) => backup.status === BackupStatus.IN_PROGRESS,
+ );
+
+ if (!hasInProgressBackups) {
+ return;
+ }
+
+ const timeoutId = setTimeout(async () => {
+ await reloadInProgressBackups();
}, 1_000);
- return () => clearInterval(interval);
- }, [database]);
+ return () => clearTimeout(timeoutId);
+ }, [backups]);
useEffect(() => {
if (downloadingBackupId) {
@@ -152,6 +243,26 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
}
}, [downloadingBackupId]);
+ useEffect(() => {
+ if (!scrollContainerRef?.current) {
+ return;
+ }
+
+ const handleScroll = () => {
+ if (!scrollContainerRef.current) return;
+
+ const { scrollTop, scrollHeight, clientHeight } = scrollContainerRef.current;
+
+ if (scrollHeight - scrollTop <= clientHeight + 100 && hasMore && !isLoadingMore) {
+ loadMoreBackups();
+ }
+ };
+
+ const container = scrollContainerRef.current;
+ container.addEventListener('scroll', handleScroll);
+ return () => container.removeEventListener('scroll', handleScroll);
+ }, [hasMore, isLoadingMore, currentLimit, scrollContainerRef]);
+
const columns: ColumnsType<Backup> = [
{
title: 'Created at',
@@ -348,14 +459,16 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
);
}
- if (!isShowBackupConfig) {
- return <div />;
- }
-
return (
<div className="mt-5 w-full rounded-md bg-white p-5 shadow">
<h2 className="text-xl font-bold">Backups</h2>
+ {!isBackupConfigLoading && !backupConfig?.isBackupsEnabled && (
+ <div className="text-red-600">
+ Scheduled backups are disabled (you can enable it back in the backup configuration)
+ </div>
+ )}
+
<div className="mt-5" />
<div className="flex">
@@ -380,6 +493,16 @@ export const BackupsComponent = ({ database, isCanManageDBs }: Props) => {
size="small"
pagination={false}
/>
+ {isLoadingMore && (
+ <div className="mt-2 flex justify-center">
+ <Spin />
+ </div>
+ )}
+ {!hasMore && backups.length > 0 && (
+ <div className="mt-2 text-center text-gray-500">
+ All backups loaded ({totalBackups} total)
+ </div>
+ )}
</div>
{deleteConfimationId && (
diff --git a/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx b/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx
index a8a98e7a..40d54bb4 100644
--- a/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx
+++ b/frontend/src/features/backups/ui/EditBackupConfigComponent.tsx
@@ -74,7 +74,6 @@ export const EditBackupConfigComponent = ({
const [isShowCreateStorage, setShowCreateStorage] = useState(false);
const [isShowWarn, setIsShowWarn] = useState(false);
- const [isShowBackupDisableConfirm, setIsShowBackupDisableConfirm] = useState(false);
const timeFormat = useMemo(() => {
const is12 = getUserTimeFormat();
@@ -208,12 +207,7 @@ export const EditBackupConfigComponent = ({
<Switch
checked={backupConfig.isBackupsEnabled}
onChange={(checked) => {
- // If disabling backups on existing database, show confirmation
- if (!checked && database.id && backupConfig.isBackupsEnabled) {
- setIsShowBackupDisableConfirm(true);
- } else {
- updateBackupConfig({ isBackupsEnabled: checked });
- }
+ updateBackupConfig({ isBackupsEnabled: checked });
}}
size="small"
/>
@@ -385,41 +379,47 @@ export const EditBackupConfigComponent = ({
</Tooltip>
</div>
- <div className="mt-5 mb-1 flex w-full items-center">
- <div className="min-w-[150px]">Storage</div>
- <Select
- value={backupConfig.storage?.id}
- onChange={(storageId) => {
- if (storageId.includes('create-new-storage')) {
- setShowCreateStorage(true);
- return;
- }
-
- const selectedStorage = storages.find((s) => s.id === storageId);
- updateBackupConfig({ storage: selectedStorage });
-
- if (backupConfig.storage?.id) {
- setIsShowWarn(true);
- }
- }}
- size="small"
- className="mr-2 max-w-[200px] grow"
- options={[
- ...storages.map((s) => ({ label: s.name, value: s.id })),
- { label: 'Create new storage', value: 'create-new-storage' },
- ]}
- placeholder="Select storage"
- />
+ <div className="mb-3" />
+ </>
+ )}
- {backupConfig.storage?.type && (
- <img
- src={getStorageLogoFromType(backupConfig.storage.type)}
- alt="storageIcon"
- className="ml-1 h-4 w-4"
- />
- )}
- </div>
+ <div className="mt-2 mb-1 flex w-full items-center">
+ <div className="min-w-[150px]">Storage</div>
+ <Select
+ value={backupConfig.storage?.id}
+ onChange={(storageId) => {
+ if (storageId.includes('create-new-storage')) {
+ setShowCreateStorage(true);
+ return;
+ }
+
+ const selectedStorage = storages.find((s) => s.id === storageId);
+ updateBackupConfig({ storage: selectedStorage });
+
+ if (backupConfig.storage?.id) {
+ setIsShowWarn(true);
+ }
+ }}
+ size="small"
+ className="mr-2 max-w-[200px] grow"
+ options={[
+ ...storages.map((s) => ({ label: s.name, value: s.id })),
+ { label: 'Create new storage', value: 'create-new-storage' },
+ ]}
+ placeholder="Select storage"
+ />
+
+ {backupConfig.storage?.type && (
+ <img
+ src={getStorageLogoFromType(backupConfig.storage.type)}
+ alt="storageIcon"
+ className="ml-1 h-4 w-4"
+ />
+ )}
+ </div>
+ {backupConfig.isBackupsEnabled && (
+ <>
<div className="mt-4 mb-1 flex w-full items-start">
<div className="mt-1 min-w-[150px]">Notifications</div>
<div className="flex flex-col space-y-2">
@@ -526,22 +526,6 @@ export const EditBackupConfigComponent = ({
hideCancelButton
/>
)}
-
- {isShowBackupDisableConfirm && (
- <ConfirmationComponent
- onConfirm={() => {
- updateBackupConfig({ isBackupsEnabled: false });
- setIsShowBackupDisableConfirm(false);
- }}
- onDecline={() => {
- setIsShowBackupDisableConfirm(false);
- }}
- description="All current backups will be removed? Are you sure?"
- actionButtonColor="red"
- actionText="Yes, disable backing up and remove all existing backup files"
- cancelText="Cancel"
- />
- )}
</div>
);
};
diff --git a/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx b/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx
index fb18571d..e6db465d 100644
--- a/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx
+++ b/frontend/src/features/backups/ui/ShowBackupConfigComponent.tsx
@@ -99,7 +99,9 @@ export const ShowBackupConfigComponent = ({ database }: Props) => {
<div>
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px]">Backups enabled</div>
- <div>{backupConfig.isBackupsEnabled ? 'Yes' : 'No'}</div>
+ <div className={backupConfig.isBackupsEnabled ? '' : 'font-bold text-red-600'}>
+ {backupConfig.isBackupsEnabled ? 'Yes' : 'No'}
+ </div>
</div>
{backupConfig.isBackupsEnabled ? (
diff --git a/frontend/src/features/databases/ui/DatabaseComponent.tsx b/frontend/src/features/databases/ui/DatabaseComponent.tsx
index b5efb951..e59e5fe0 100644
--- a/frontend/src/features/databases/ui/DatabaseComponent.tsx
+++ b/frontend/src/features/databases/ui/DatabaseComponent.tsx
@@ -1,5 +1,5 @@
import { Spin } from 'antd';
-import { useState } from 'react';
+import { useRef, useState } from 'react';
import { useEffect } from 'react';
import { type Database, databaseApi } from '../../../entity/databases';
@@ -27,6 +27,8 @@ export const DatabaseComponent = ({
const [database, setDatabase] = useState<Database | undefined>();
const [editDatabase, setEditDatabase] = useState<Database | undefined>();
+ const scrollContainerRef = useRef<HTMLDivElement>(null);
+
const loadSettings = () => {
setDatabase(undefined);
setEditDatabase(undefined);
@@ -42,7 +44,11 @@ export const DatabaseComponent = ({
}
return (
- <div className="w-full overflow-y-auto" style={{ maxHeight: contentHeight }}>
+ <div
+ className="w-full overflow-y-auto"
+ style={{ maxHeight: contentHeight }}
+ ref={scrollContainerRef}
+ >
<div className="flex">
<div
className={`mr-2 cursor-pointer rounded-tl-md rounded-tr-md px-6 py-2 ${currentTab === 'config' ? 'bg-white' : 'bg-gray-200'}`}
@@ -73,7 +79,11 @@ export const DatabaseComponent = ({
{currentTab === 'backups' && (
<>
<HealthckeckAttemptsComponent database={database} />
- <BackupsComponent database={database} isCanManageDBs={isCanManageDBs} />
+ <BackupsComponent
+ database={database}
+ isCanManageDBs={isCanManageDBs}
+ scrollContainerRef={scrollContainerRef}
+ />
</>
)}
</div>
diff --git a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx
index fef61bf2..52e836ba 100644
--- a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx
+++ b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx
@@ -100,7 +100,7 @@ export const EditDatabaseSpecificDataComponent = ({
if (!editingDatabase.postgresql?.host) isAllFieldsFilled = false;
if (!editingDatabase.postgresql?.port) isAllFieldsFilled = false;
if (!editingDatabase.postgresql?.username) isAllFieldsFilled = false;
- if (!editingDatabase.postgresql?.password) isAllFieldsFilled = false;
+ if (!editingDatabase.id && !editingDatabase.postgresql?.password) isAllFieldsFilled = false;
if (!editingDatabase.postgresql?.database) isAllFieldsFilled = false;
return (
@@ -161,6 +161,7 @@ export const EditDatabaseSpecificDataComponent = ({
host: e.target.value.trim().replace('https://', '').replace('http://', ''),
},
});
+ setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
@@ -199,6 +200,7 @@ export const EditDatabaseSpecificDataComponent = ({
...editingDatabase,
postgresql: { ...editingDatabase.postgresql, username: e.target.value.trim() },
});
+ setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
diff --git a/frontend/src/features/databases/ui/show/ShowDatabaseSpecificDataComponent.tsx b/frontend/src/features/databases/ui/show/ShowDatabaseSpecificDataComponent.tsx
index d5e083b9..0a9d0e8f 100644
--- a/frontend/src/features/databases/ui/show/ShowDatabaseSpecificDataComponent.tsx
+++ b/frontend/src/features/databases/ui/show/ShowDatabaseSpecificDataComponent.tsx
@@ -44,7 +44,7 @@ export const ShowDatabaseSpecificDataComponent = ({ database }: Props) => {
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px]">Password</div>
- <div>{database.postgresql?.password ? '*********' : ''}</div>
+ <div>{'*************'}</div>
</div>
<div className="mb-1 flex w-full items-center">
diff --git a/frontend/src/features/notifiers/ui/edit/EditNotifierComponent.tsx b/frontend/src/features/notifiers/ui/edit/EditNotifierComponent.tsx
index 9c5c536e..1e80f2b7 100644
--- a/frontend/src/features/notifiers/ui/edit/EditNotifierComponent.tsx
+++ b/frontend/src/features/notifiers/ui/edit/EditNotifierComponent.tsx
@@ -176,27 +176,27 @@ export function EditNotifierComponent({
if (!notifier.name) return false;
if (notifier.notifierType === NotifierType.TELEGRAM && notifier.telegramNotifier) {
- return validateTelegramNotifier(notifier.telegramNotifier);
+ return validateTelegramNotifier(!notifier.id, notifier.telegramNotifier);
}
if (notifier.notifierType === NotifierType.EMAIL && notifier.emailNotifier) {
- return validateEmailNotifier(notifier.emailNotifier);
+ return validateEmailNotifier(!notifier.id, notifier.emailNotifier);
}
if (notifier.notifierType === NotifierType.WEBHOOK && notifier.webhookNotifier) {
- return validateWebhookNotifier(notifier.webhookNotifier);
+ return validateWebhookNotifier(!notifier.id, notifier.webhookNotifier);
}
if (notifier.notifierType === NotifierType.SLACK && notifier.slackNotifier) {
- return validateSlackNotifier(notifier.slackNotifier);
+ return validateSlackNotifier(!notifier.id, notifier.slackNotifier);
}
if (notifier.notifierType === NotifierType.DISCORD && notifier.discordNotifier) {
- return validateDiscordNotifier(notifier.discordNotifier);
+ return validateDiscordNotifier(!notifier.id, notifier.discordNotifier);
}
if (notifier.notifierType === NotifierType.TEAMS && notifier.teamsNotifier) {
- return validateTeamsNotifier(notifier.teamsNotifier);
+ return validateTeamsNotifier(!notifier.id, notifier.teamsNotifier);
}
return false;
diff --git a/frontend/src/features/notifiers/ui/show/notifier/ShowEmailNotifierComponent.tsx b/frontend/src/features/notifiers/ui/show/notifier/ShowEmailNotifierComponent.tsx
index f9980b31..99fb225b 100644
--- a/frontend/src/features/notifiers/ui/show/notifier/ShowEmailNotifierComponent.tsx
+++ b/frontend/src/features/notifiers/ui/show/notifier/ShowEmailNotifierComponent.tsx
@@ -29,7 +29,7 @@ export function ShowEmailNotifierComponent({ notifier }: Props) {
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">SMTP password</div>
- {notifier?.emailNotifier?.smtpPassword ? '*********' : ''}
+ {'*************'}
</div>
</>
);
diff --git a/frontend/src/features/storages/ui/edit/EditStorageComponent.tsx b/frontend/src/features/storages/ui/edit/EditStorageComponent.tsx
index d9f3d9d4..c90fb26f 100644
--- a/frontend/src/features/storages/ui/edit/EditStorageComponent.tsx
+++ b/frontend/src/features/storages/ui/edit/EditStorageComponent.tsx
@@ -155,6 +155,10 @@ export function EditStorageComponent({
}
if (storage.type === StorageType.S3) {
+ if (storage.id) {
+ return storage.s3Storage?.s3Bucket;
+ }
+
return (
storage.s3Storage?.s3Bucket &&
storage.s3Storage?.s3AccessKey &&
@@ -163,6 +167,10 @@ export function EditStorageComponent({
}
if (storage.type === StorageType.GOOGLE_DRIVE) {
+ if (storage.id) {
+ return storage.googleDriveStorage?.clientId;
+ }
+
return (
storage.googleDriveStorage?.clientId &&
storage.googleDriveStorage?.clientSecret &&
@@ -171,6 +179,15 @@ export function EditStorageComponent({
}
if (storage.type === StorageType.NAS) {
+ if (storage.id) {
+ return (
+ storage.nasStorage?.host &&
+ storage.nasStorage?.port &&
+ storage.nasStorage?.share &&
+ storage.nasStorage?.username
+ );
+ }
+
return (
storage.nasStorage?.host &&
storage.nasStorage?.port &&
diff --git a/frontend/src/features/storages/ui/show/storages/ShowGoogleDriveStorageComponent.tsx b/frontend/src/features/storages/ui/show/storages/ShowGoogleDriveStorageComponent.tsx
index f753df9a..66617d20 100644
--- a/frontend/src/features/storages/ui/show/storages/ShowGoogleDriveStorageComponent.tsx
+++ b/frontend/src/features/storages/ui/show/storages/ShowGoogleDriveStorageComponent.tsx
@@ -16,16 +16,12 @@ export function ShowGoogleDriveStorageComponent({ storage }: Props) {
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">Client Secret</div>
- {storage?.googleDriveStorage?.clientSecret
- ? `${storage?.googleDriveStorage?.clientSecret.slice(0, 10)}***`
- : '-'}
+ {`*************`}
</div>
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">User Token</div>
- {storage?.googleDriveStorage?.tokenJson
- ? `${storage?.googleDriveStorage?.tokenJson.slice(0, 10)}***`
- : '-'}
+ {`*************`}
</div>
</>
);
diff --git a/frontend/src/features/storages/ui/show/storages/ShowNASStorageComponent.tsx b/frontend/src/features/storages/ui/show/storages/ShowNASStorageComponent.tsx
index f4264dcb..faae8b20 100644
--- a/frontend/src/features/storages/ui/show/storages/ShowNASStorageComponent.tsx
+++ b/frontend/src/features/storages/ui/show/storages/ShowNASStorageComponent.tsx
@@ -29,7 +29,7 @@ export function ShowNASStorageComponent({ storage }: Props) {
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">Password</div>
- {storage?.nasStorage?.password ? '*********' : '-'}
+ {'*************'}
</div>
<div className="mb-1 flex items-center">
diff --git a/frontend/src/features/storages/ui/show/storages/ShowS3StorageComponent.tsx b/frontend/src/features/storages/ui/show/storages/ShowS3StorageComponent.tsx
index e7b57a93..f35bba35 100644
--- a/frontend/src/features/storages/ui/show/storages/ShowS3StorageComponent.tsx
+++ b/frontend/src/features/storages/ui/show/storages/ShowS3StorageComponent.tsx
@@ -14,17 +14,17 @@ export function ShowS3StorageComponent({ storage }: Props) {
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">Region</div>
- {storage?.s3Storage?.s3Region}
+ {storage?.s3Storage?.s3Region || '-'}
</div>
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">Access Key</div>
- {storage?.s3Storage?.s3AccessKey ? '*********' : ''}
+ {'*************'}
</div>
<div className="mb-1 flex items-center">
<div className="min-w-[110px]">Secret Key</div>
- {storage?.s3Storage?.s3SecretKey ? '*********' : ''}
+ {'*************'}
</div>
<div className="mb-1 flex items-center">
diff --git a/frontend/src/pages/OauthStorageComponent.tsx b/frontend/src/pages/OauthStorageComponent.tsx
new file mode 100644
index 00000000..9f26a52b
--- /dev/null
+++ b/frontend/src/pages/OauthStorageComponent.tsx
@@ -0,0 +1,105 @@
+import { Modal, Spin } from 'antd';
+import { useEffect, useState } from 'react';
+
+import { GOOGLE_DRIVE_OAUTH_REDIRECT_URL } from '../constants';
+import { type Storage, StorageType } from '../entity/storages';
+import type { StorageOauthDto } from '../entity/storages/models/StorageOauthDto';
+import { EditStorageComponent } from '../features/storages/ui/edit/EditStorageComponent';
+
+export function OauthStorageComponent() {
+ const [storage, setStorage] = useState<Storage | undefined>();
+
+ const exchangeGoogleOauthCode = async (oauthDto: StorageOauthDto) => {
+ if (!oauthDto.storage.googleDriveStorage) {
+ alert('Google Drive storage configuration not found');
+ return;
+ }
+
+ const { clientId, clientSecret } = oauthDto.storage.googleDriveStorage;
+ const { authCode } = oauthDto;
+
+ try {
+ // Exchange authorization code for access token
+ const response = await fetch('https://oauth2.googleapis.com/token', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/x-www-form-urlencoded',
+ },
+ body: new URLSearchParams({
+ code: authCode,
+ client_id: clientId,
+ client_secret: clientSecret,
+ redirect_uri: GOOGLE_DRIVE_OAUTH_REDIRECT_URL,
+ grant_type: 'authorization_code',
+ }),
+ });
+
+ if (!response.ok) {
+ throw new Error(`OAuth exchange failed: ${response.statusText}`);
+ }
+
+ const tokenData = await response.json();
+
+ oauthDto.storage.googleDriveStorage.tokenJson = JSON.stringify(tokenData);
+ setStorage(oauthDto.storage);
+ } catch (error) {
+ alert(`Failed to exchange OAuth code: ${error}`);
+ }
+ };
+
+ useEffect(() => {
+ const oauthDtoParam = new URLSearchParams(window.location.search).get('oauthDto');
+ if (!oauthDtoParam) {
+ alert('OAuth param not found');
+ return;
+ }
+
+ const decodedParam = decodeURIComponent(oauthDtoParam);
+ const oauthDto: StorageOauthDto = JSON.parse(decodedParam);
+
+ if (oauthDto.storage.type === StorageType.GOOGLE_DRIVE) {
+ if (!oauthDto.storage.googleDriveStorage) {
+ alert('Google Drive storage not found');
+ return;
+ }
+
+ exchangeGoogleOauthCode(oauthDto);
+ }
+ }, []);
+
+ if (!storage) {
+ return (
+ <div className="mt-20 flex justify-center">
+ <Spin />
+ </div>
+ );
+ }
+
+ return (
+ <div>
+ <Modal
+ title="Add storage"
+ footer={<div />}
+ open
+ onCancel={() => {
+ window.location.href = '/';
+ }}
+ >
+ <div className="my-3 max-w-[250px] text-gray-500">
+ Storage - is a place where backups will be stored (local disk, S3, etc.)
+ </div>
+
+ <EditStorageComponent
+ workspaceId={storage.workspaceId}
+ isShowClose={false}
+ onClose={() => {}}
+ isShowName={false}
+ editingStorage={storage}
+ onChanged={() => {
+ window.location.href = '/';
+ }}
+ />
+ </Modal>
+ </div>
+ );
+}