PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FEATURE (restores): Allow to exclude extensions over restore
Rostislav Duginc6261d434b17
diff --git a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.goindex b7c9e957..79e3db93 100644--- a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go@@ -131,7 +131,8 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(}defer func() {if pgpassFile != "" {- _ = os.Remove(pgpassFile)+ // Remove the entire temp directory (which contains the .pgpass file)+ _ = os.RemoveAll(filepath.Dir(pgpassFile))}}()diff --git a/backend/internal/features/databases/databases/postgresql/model.go b/backend/internal/features/databases/databases/postgresql/model.goindex d28d7497..83143883 100644--- a/backend/internal/features/databases/databases/postgresql/model.go+++ b/backend/internal/features/databases/databases/postgresql/model.go@@ -34,6 +34,9 @@ type PostgresqlDatabase struct {// backup settingsIncludeSchemas []string `json:"includeSchemas" gorm:"-"`IncludeSchemasString string `json:"-" gorm:"column:include_schemas;type:text;not null;default:''"`++ // restore settings (not saved to DB)+ IsExcludeExtensions bool `json:"isExcludeExtensions" gorm:"-"`}func (p *PostgresqlDatabase) TableName() string {diff --git a/backend/internal/features/restores/controller_test.go b/backend/internal/features/restores/controller_test.goindex 2d247da5..c02b74d3 100644--- a/backend/internal/features/restores/controller_test.go+++ b/backend/internal/features/restores/controller_test.go@@ -171,6 +171,36 @@ func Test_RestoreBackup_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testingassert.Contains(t, string(testResp.Body), "insufficient permissions")}+func Test_RestoreBackup_WithIsExcludeExtensions_FlagPassedCorrectly(t *testing.T) {+ router := createTestRouter()+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)++ _, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)++ request := RestoreBackupRequest{+ PostgresqlDatabase: &postgresql.PostgresqlDatabase{+ Version: tools.PostgresqlVersion16,+ Host: "localhost",+ Port: 5432,+ Username: "postgres",+ Password: "postgres",+ IsExcludeExtensions: true,+ },+ }++ testResp := test_utils.MakePostRequest(+ t,+ router,+ fmt.Sprintf("/api/v1/restores/%s/restore", backup.ID.String()),+ "Bearer "+owner.Token,+ request,+ http.StatusOK,+ )++ assert.Contains(t, string(testResp.Body), "restore started successfully")+}+func Test_RestoreBackup_AuditLogWritten(t *testing.T) {router := createTestRouter()owner := users_testing.CreateTestUser(users_enums.UserRoleMember)diff --git a/backend/internal/features/restores/service.go b/backend/internal/features/restores/service.goindex c5f228c1..a30e9878 100644--- a/backend/internal/features/restores/service.go+++ b/backend/internal/features/restores/service.go@@ -214,6 +214,11 @@ func (s *RestoreService) RestoreBackup(return fmt.Errorf("failed to auto-detect database version: %w", err)}+ isExcludeExtensions := false+ if requestDTO.PostgresqlDatabase != nil {+ isExcludeExtensions = requestDTO.PostgresqlDatabase.IsExcludeExtensions+ }+err = s.restoreBackupUsecase.Execute(backupConfig,restore,@@ -221,6 +226,7 @@ func (s *RestoreService) RestoreBackup(restoringToDB,backup,storage,+ isExcludeExtensions,)if err != nil {errMsg := err.Error()diff --git a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.goindex ddedd1dd..968c31cd 100644--- a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go+++ b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go@@ -42,6 +42,7 @@ func (uc *RestorePostgresqlBackupUsecase) Execute(restore models.Restore,backup *backups.Backup,storage *storages.Storage,+ isExcludeExtensions bool,) error {if originalDB.Type != databases.DatabaseTypePostgres {return errors.New("database type not supported")@@ -96,6 +97,7 @@ func (uc *RestorePostgresqlBackupUsecase) Execute(backup,storage,pg,+ isExcludeExtensions,)}@@ -108,6 +110,7 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(backup *backups.Backup,storage *storages.Storage,pgConfig *pgtypes.PostgresqlDatabase,+ isExcludeExtensions bool,) error {uc.logger.Info("Restoring PostgreSQL backup from storage via temporary file",@@ -115,6 +118,8 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(pgBin,"args",args,+ "isExcludeExtensions",+ isExcludeExtensions,)ctx, cancel := context.WithTimeout(context.Background(), 60*time.Minute)@@ -171,6 +176,26 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(}defer cleanupFunc()+ // If excluding extensions, generate filtered TOC list and use it+ if isExcludeExtensions {+ tocListFile, err := uc.generateFilteredTocList(+ ctx,+ pgBin,+ tempBackupFile,+ pgpassFile,+ pgConfig,+ )+ if err != nil {+ return fmt.Errorf("failed to generate filtered TOC list: %w", err)+ }+ defer func() {+ _ = os.Remove(tocListFile)+ }()++ // Add -L flag to use the filtered list+ args = append(args, "-L", tocListFile)+ }+// Add the temporary backup file as the last argument to pg_restoreargs = append(args, tempBackupFile)@@ -554,6 +579,75 @@ func containsIgnoreCase(str, substr string) bool {return strings.Contains(strings.ToLower(str), strings.ToLower(substr))}+// generateFilteredTocList generates a pg_restore TOC list file with extensions filtered out.+// This is used when isExcludeExtensions is true to skip CREATE EXTENSION statements.+func (uc *RestorePostgresqlBackupUsecase) generateFilteredTocList(+ ctx context.Context,+ pgBin string,+ backupFile string,+ pgpassFile string,+ pgConfig *pgtypes.PostgresqlDatabase,+) (string, error) {+ uc.logger.Info("Generating filtered TOC list to exclude extensions", "backupFile", backupFile)++ // Run pg_restore -l to get the TOC list+ listCmd := exec.CommandContext(ctx, pgBin, "-l", backupFile)+ uc.setupPgRestoreEnvironment(listCmd, pgpassFile, pgConfig)++ tocOutput, err := listCmd.Output()+ if err != nil {+ return "", fmt.Errorf("failed to generate TOC list: %w", err)+ }++ // Filter out EXTENSION lines+ var filteredLines []string+ for _, line := range strings.Split(string(tocOutput), "\n") {+ // Skip lines that contain EXTENSION (but not COMMENT ON EXTENSION)+ // TOC format: "123; 1234 12345 EXTENSION - extension_name owner"+ trimmedLine := strings.TrimSpace(line)+ if trimmedLine == "" {+ continue+ }++ // Check if this is an EXTENSION entry (not a comment about extension)+ // Extension lines look like: "3420; 0 0 EXTENSION - uuid-ossp"+ if strings.Contains(trimmedLine, " EXTENSION ") &&+ !strings.Contains(strings.ToUpper(trimmedLine), "COMMENT") {+ uc.logger.Info("Excluding extension from restore", "tocLine", trimmedLine)+ continue+ }++ filteredLines = append(filteredLines, line)+ }++ // Write filtered TOC to temporary file+ tocFile, err := os.CreateTemp("", "pg_restore_toc_*.list")+ if err != nil {+ return "", fmt.Errorf("failed to create TOC list file: %w", err)+ }+ tocFilePath := tocFile.Name()++ filteredContent := strings.Join(filteredLines, "\n")+ if _, err := tocFile.WriteString(filteredContent); err != nil {+ _ = tocFile.Close()+ _ = os.Remove(tocFilePath)+ return "", fmt.Errorf("failed to write TOC list file: %w", err)+ }++ if err := tocFile.Close(); err != nil {+ _ = os.Remove(tocFilePath)+ return "", fmt.Errorf("failed to close TOC list file: %w", err)+ }++ uc.logger.Info("Generated filtered TOC list file",+ "tocFile", tocFilePath,+ "originalLines", len(strings.Split(string(tocOutput), "\n")),+ "filteredLines", len(filteredLines),+ )++ return tocFilePath, nil+}+// createTempPgpassFile creates a temporary .pgpass file with the given passwordfunc (uc *RestorePostgresqlBackupUsecase) createTempPgpassFile(pgConfig *pgtypes.PostgresqlDatabase,diff --git a/backend/internal/features/restores/usecases/restore_backup_uc.go b/backend/internal/features/restores/usecases/restore_backup_uc.goindex 92fd16c7..2879e998 100644--- a/backend/internal/features/restores/usecases/restore_backup_uc.go+++ b/backend/internal/features/restores/usecases/restore_backup_uc.go@@ -21,6 +21,7 @@ func (uc *RestoreBackupUsecase) Execute(restoringToDB *databases.Database,backup *backups.Backup,storage *storages.Storage,+ isExcludeExtensions bool,) error {if originalDB.Type == databases.DatabaseTypePostgres {return uc.restorePostgresqlBackupUsecase.Execute(@@ -30,6 +31,7 @@ func (uc *RestoreBackupUsecase) Execute(restore,backup,storage,+ isExcludeExtensions,)}diff --git a/backend/internal/features/tests/postgresql_backup_restore_test.go b/backend/internal/features/tests/postgresql_backup_restore_test.goindex eb6272eb..a4930bc4 100644--- a/backend/internal/features/tests/postgresql_backup_restore_test.go+++ b/backend/internal/features/tests/postgresql_backup_restore_test.go@@ -243,8 +243,186 @@ func Test_BackupAndRestoreSupabase_PublicSchemaOnly_RestoreIsSuccessful(t *testifunc Test_BackupPostgresql_SchemaSelection_AllSchemasWhenNoneSpecified(t *testing.T) {env := config.GetEnv()+ cases := []struct {+ name string+ version string+ port string+ }{+ {"PostgreSQL 12", "12", env.TestPostgres12Port},+ {"PostgreSQL 13", "13", env.TestPostgres13Port},+ {"PostgreSQL 14", "14", env.TestPostgres14Port},+ {"PostgreSQL 15", "15", env.TestPostgres15Port},+ {"PostgreSQL 16", "16", env.TestPostgres16Port},+ {"PostgreSQL 17", "17", env.TestPostgres17Port},+ {"PostgreSQL 18", "18", env.TestPostgres18Port},+ }- container, err := connectToPostgresContainer("16", env.TestPostgres16Port)+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()+ testSchemaSelectionAllSchemasForVersion(t, tc.version, tc.port)+ })+ }+}++func Test_BackupAndRestorePostgresql_WithExcludeExtensions_RestoreIsSuccessful(t *testing.T) {+ env := config.GetEnv()+ cases := []struct {+ name string+ version string+ port string+ }{+ {"PostgreSQL 12", "12", env.TestPostgres12Port},+ {"PostgreSQL 13", "13", env.TestPostgres13Port},+ {"PostgreSQL 14", "14", env.TestPostgres14Port},+ {"PostgreSQL 15", "15", env.TestPostgres15Port},+ {"PostgreSQL 16", "16", env.TestPostgres16Port},+ {"PostgreSQL 17", "17", env.TestPostgres17Port},+ {"PostgreSQL 18", "18", env.TestPostgres18Port},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()+ testBackupRestoreWithExcludeExtensionsForVersion(t, tc.version, tc.port)+ })+ }+}++func Test_BackupAndRestorePostgresql_WithoutExcludeExtensions_ExtensionsAreRecovered(t *testing.T) {+ env := config.GetEnv()+ cases := []struct {+ name string+ version string+ port string+ }{+ {"PostgreSQL 12", "12", env.TestPostgres12Port},+ {"PostgreSQL 13", "13", env.TestPostgres13Port},+ {"PostgreSQL 14", "14", env.TestPostgres14Port},+ {"PostgreSQL 15", "15", env.TestPostgres15Port},+ {"PostgreSQL 16", "16", env.TestPostgres16Port},+ {"PostgreSQL 17", "17", env.TestPostgres17Port},+ {"PostgreSQL 18", "18", env.TestPostgres18Port},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()+ testBackupRestoreWithoutExcludeExtensionsForVersion(t, tc.version, tc.port)+ })+ }+}++func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {+ env := config.GetEnv()+ cases := []struct {+ name string+ version string+ port string+ }{+ {"PostgreSQL 12", "12", env.TestPostgres12Port},+ {"PostgreSQL 13", "13", env.TestPostgres13Port},+ {"PostgreSQL 14", "14", env.TestPostgres14Port},+ {"PostgreSQL 15", "15", env.TestPostgres15Port},+ {"PostgreSQL 16", "16", env.TestPostgres16Port},+ {"PostgreSQL 17", "17", env.TestPostgres17Port},+ {"PostgreSQL 18", "18", env.TestPostgres18Port},+ }++ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()+ testSchemaSelectionOnlySpecifiedSchemasForVersion(t, tc.version, tc.port)+ })+ }+}++func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {+ container, err := connectToPostgresContainer(pgVersion, port)+ assert.NoError(t, err)+ defer func() {+ if container.DB != nil {+ container.DB.Close()+ }+ }()++ _, err = container.DB.Exec(createAndFillTableQuery)+ assert.NoError(t, err)++ router := createTestRouter()+ user := users_testing.CreateTestUser(users_enums.UserRoleMember)+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)++ storage := storages.CreateTestStorage(workspace.ID)++ database := createDatabaseViaAPI(+ t, router, "Test Database", workspace.ID,+ container.Host, container.Port,+ container.Username, container.Password, container.Database,+ user.Token,+ )++ enableBackupsViaAPI(+ t, router, database.ID, storage.ID,+ backups_config.BackupEncryptionNone, user.Token,+ )++ createBackupViaAPI(t, router, database.ID, user.Token)++ backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)+ assert.Equal(t, backups.BackupStatusCompleted, backup.Status)++ newDBName := "restoreddb"+ _, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))+ assert.NoError(t, err)++ _, err = container.DB.Exec(fmt.Sprintf("CREATE DATABASE %s;", newDBName))+ assert.NoError(t, err)++ newDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ container.Host, container.Port, container.Username, container.Password, newDBName)+ newDB, err := sqlx.Connect("postgres", newDSN)+ assert.NoError(t, err)+ defer newDB.Close()++ createRestoreViaAPI(+ t, router, backup.ID,+ container.Host, container.Port,+ container.Username, container.Password, newDBName,+ user.Token,+ )++ restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)+ assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)++ var tableExists bool+ err = newDB.Get(+ &tableExists,+ "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'test_data')",+ )+ assert.NoError(t, err)+ assert.True(t, tableExists, "Table 'test_data' should exist in restored database")++ verifyDataIntegrity(t, container.DB, newDB)++ err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))+ if err != nil {+ t.Logf("Warning: Failed to delete backup file: %v", err)+ }++ test_utils.MakeDeleteRequest(+ t,+ router,+ "/api/v1/databases/"+database.ID.String(),+ "Bearer "+user.Token,+ http.StatusNoContent,+ )+ storages.RemoveTestStorage(storage.ID)+ workspaces_testing.RemoveTestWorkspace(workspace, router)+}++func testSchemaSelectionAllSchemasForVersion(t *testing.T, pgVersion string, port string) {+ container, err := connectToPostgresContainer(pgVersion, port)assert.NoError(t, err)defer container.DB.Close()@@ -296,7 +474,7 @@ func Test_BackupPostgresql_SchemaSelection_AllSchemasWhenNoneSpecified(t *testinbackup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)assert.Equal(t, backups.BackupStatusCompleted, backup.Status)- newDBName := "restored_all_schemas"+ newDBName := "restored_all_schemas_" + pgVersion_, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))assert.NoError(t, err)@@ -365,48 +543,44 @@ func Test_BackupPostgresql_SchemaSelection_AllSchemasWhenNoneSpecified(t *testinworkspaces_testing.RemoveTestWorkspace(workspace, router)}-func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {- env := config.GetEnv()-- container, err := connectToPostgresContainer("16", env.TestPostgres16Port)+func testBackupRestoreWithExcludeExtensionsForVersion(t *testing.T, pgVersion string, port string) {+ container, err := connectToPostgresContainer(pgVersion, port)assert.NoError(t, err)defer container.DB.Close()+ // Create table with uuid-ossp extension_, err = container.DB.Exec(`- DROP SCHEMA IF EXISTS schema_a CASCADE;- DROP SCHEMA IF EXISTS schema_b CASCADE;- CREATE SCHEMA schema_a;- CREATE SCHEMA schema_b;+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;+ CREATE EXTENSION IF NOT EXISTS "uuid-ossp";- CREATE TABLE public.public_table (id SERIAL PRIMARY KEY, data TEXT);- CREATE TABLE schema_a.table_a (id SERIAL PRIMARY KEY, data TEXT);- CREATE TABLE schema_b.table_b (id SERIAL PRIMARY KEY, data TEXT);+ DROP TABLE IF EXISTS test_extension_data;+ CREATE TABLE test_extension_data (+ id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),+ name TEXT NOT NULL,+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()+ );- INSERT INTO public.public_table (data) VALUES ('public_data');- INSERT INTO schema_a.table_a (data) VALUES ('schema_a_data');- INSERT INTO schema_b.table_b (data) VALUES ('schema_b_data');+ INSERT INTO test_extension_data (name) VALUES ('test1'), ('test2'), ('test3');`)assert.NoError(t, err)defer func() {_, _ = container.DB.Exec(`- DROP TABLE IF EXISTS public.public_table;- DROP SCHEMA IF EXISTS schema_a CASCADE;- DROP SCHEMA IF EXISTS schema_b CASCADE;+ DROP TABLE IF EXISTS test_extension_data;+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;`)}()router := createTestRouter()user := users_testing.CreateTestUser(users_enums.UserRoleMember)- workspace := workspaces_testing.CreateTestWorkspace("Schema Test Workspace", user, router)+ workspace := workspaces_testing.CreateTestWorkspace("Extension Test Workspace", user, router)storage := storages.CreateTestStorage(workspace.ID)- database := createDatabaseWithSchemasViaAPI(- t, router, "Specific Schemas Database", workspace.ID,+ database := createDatabaseViaAPI(+ t, router, "Extension Test Database", workspace.ID,container.Host, container.Port,container.Username, container.Password, container.Database,- []string{"public", "schema_a"},user.Token,)@@ -420,7 +594,8 @@ func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)assert.Equal(t, backups.BackupStatusCompleted, backup.Status)- newDBName := "restored_specific_schemas"+ // Create new database for restore with extension pre-installed+ newDBName := "restored_exclude_ext_" + pgVersion_, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))assert.NoError(t, err)@@ -433,46 +608,191 @@ func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {assert.NoError(t, err)defer newDB.Close()- createRestoreViaAPI(+ // Pre-install the extension in the target database (simulating managed service behavior)+ _, err = newDB.Exec(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp";`)+ assert.NoError(t, err)++ // Restore with isExcludeExtensions=true+ createRestoreWithOptionsViaAPI(t, router, backup.ID,container.Host, container.Port,container.Username, container.Password, newDBName,+ true, // isExcludeExtensionsuser.Token,)restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)- var publicTableExists bool- err = newDB.Get(&publicTableExists, `+ // Verify the table was restored+ var tableExists bool+ err = newDB.Get(&tableExists, `SELECT EXISTS (SELECT FROM information_schema.tables- WHERE table_schema = 'public' AND table_name = 'public_table'+ WHERE table_schema = 'public' AND table_name = 'test_extension_data')`)assert.NoError(t, err)- assert.True(t, publicTableExists, "public.public_table should exist (was included)")+ assert.True(t, tableExists, "test_extension_data should exist in restored database")- var schemaATableExists bool- err = newDB.Get(&schemaATableExists, `+ // Verify data was restored+ var count int+ err = newDB.Get(&count, `SELECT COUNT(*) FROM test_extension_data`)+ assert.NoError(t, err)+ assert.Equal(t, 3, count, "Should have 3 rows after restore")++ // Verify extension still works (uuid_generate_v4 should work)+ var newUUID string+ err = newDB.Get(&newUUID, `SELECT uuid_generate_v4()::text`)+ assert.NoError(t, err)+ assert.NotEmpty(t, newUUID, "uuid_generate_v4 should work")++ // Cleanup+ err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))+ if err != nil {+ t.Logf("Warning: Failed to delete backup file: %v", err)+ }++ test_utils.MakeDeleteRequest(+ t,+ router,+ "/api/v1/databases/"+database.ID.String(),+ "Bearer "+user.Token,+ http.StatusNoContent,+ )+ storages.RemoveTestStorage(storage.ID)+ workspaces_testing.RemoveTestWorkspace(workspace, router)+}++func testBackupRestoreWithoutExcludeExtensionsForVersion(+ t *testing.T,+ pgVersion string,+ port string,+) {+ container, err := connectToPostgresContainer(pgVersion, port)+ assert.NoError(t, err)+ defer container.DB.Close()++ // Create table with uuid-ossp extension+ _, err = container.DB.Exec(`+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;+ CREATE EXTENSION IF NOT EXISTS "uuid-ossp";++ DROP TABLE IF EXISTS test_extension_recovery;+ CREATE TABLE test_extension_recovery (+ id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),+ name TEXT NOT NULL,+ created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()+ );++ INSERT INTO test_extension_recovery (name) VALUES ('test1'), ('test2'), ('test3');+ `)+ assert.NoError(t, err)++ defer func() {+ _, _ = container.DB.Exec(`+ DROP TABLE IF EXISTS test_extension_recovery;+ DROP EXTENSION IF EXISTS "uuid-ossp" CASCADE;+ `)+ }()++ router := createTestRouter()+ user := users_testing.CreateTestUser(users_enums.UserRoleMember)+ workspace := workspaces_testing.CreateTestWorkspace(+ "Extension Recovery Test Workspace",+ user,+ router,+ )++ storage := storages.CreateTestStorage(workspace.ID)++ database := createDatabaseViaAPI(+ t, router, "Extension Recovery Test Database", workspace.ID,+ container.Host, container.Port,+ container.Username, container.Password, container.Database,+ user.Token,+ )++ enableBackupsViaAPI(+ t, router, database.ID, storage.ID,+ backups_config.BackupEncryptionNone, user.Token,+ )++ createBackupViaAPI(t, router, database.ID, user.Token)++ backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)+ assert.Equal(t, backups.BackupStatusCompleted, backup.Status)++ // Create new database for restore WITHOUT pre-installed extension+ newDBName := "restored_with_ext_" + pgVersion+ _, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))+ assert.NoError(t, err)++ _, err = container.DB.Exec(fmt.Sprintf("CREATE DATABASE %s;", newDBName))+ assert.NoError(t, err)++ newDSN := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",+ container.Host, container.Port, container.Username, container.Password, newDBName)+ newDB, err := sqlx.Connect("postgres", newDSN)+ assert.NoError(t, err)+ defer newDB.Close()++ // Verify extension does NOT exist before restore+ var extensionExistsBefore bool+ err = newDB.Get(&extensionExistsBefore, `SELECT EXISTS (- SELECT FROM information_schema.tables- WHERE table_schema = 'schema_a' AND table_name = 'table_a'+ SELECT FROM pg_extension WHERE extname = 'uuid-ossp')`)assert.NoError(t, err)- assert.True(t, schemaATableExists, "schema_a.table_a should exist (was included)")+ assert.False(t, extensionExistsBefore, "Extension should NOT exist before restore")- var schemaBTableExists bool- err = newDB.Get(&schemaBTableExists, `+ // Restore with isExcludeExtensions=false (extensions should be recovered)+ createRestoreWithOptionsViaAPI(+ t, router, backup.ID,+ container.Host, container.Port,+ container.Username, container.Password, newDBName,+ false, // isExcludeExtensions = false means extensions ARE included+ user.Token,+ )++ restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)+ assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)++ // Verify the extension was recovered+ var extensionExists bool+ err = newDB.Get(&extensionExists, `+ SELECT EXISTS (+ SELECT FROM pg_extension WHERE extname = 'uuid-ossp'+ )+ `)+ assert.NoError(t, err)+ assert.True(t, extensionExists, "Extension 'uuid-ossp' should be recovered during restore")++ // Verify the table was restored+ var tableExists bool+ err = newDB.Get(&tableExists, `SELECT EXISTS (SELECT FROM information_schema.tables- WHERE table_schema = 'schema_b' AND table_name = 'table_b'+ WHERE table_schema = 'public' AND table_name = 'test_extension_recovery')`)assert.NoError(t, err)- assert.False(t, schemaBTableExists, "schema_b.table_b should NOT exist (was excluded)")+ assert.True(t, tableExists, "test_extension_recovery should exist in restored database")++ // Verify data was restored+ var count int+ err = newDB.Get(&count, `SELECT COUNT(*) FROM test_extension_recovery`)+ assert.NoError(t, err)+ assert.Equal(t, 3, count, "Should have 3 rows after restore")+ // Verify extension works (uuid_generate_v4 should work)+ var newUUID string+ err = newDB.Get(&newUUID, `SELECT uuid_generate_v4()::text`)+ assert.NoError(t, err)+ assert.NotEmpty(t, newUUID, "uuid_generate_v4 should work after extension recovery")++ // Cleanuperr = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))if err != nil {t.Logf("Warning: Failed to delete backup file: %v", err)@@ -489,28 +809,50 @@ func Test_BackupPostgresql_SchemaSelection_OnlySpecifiedSchemas(t *testing.T) {workspaces_testing.RemoveTestWorkspace(workspace, router)}-func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {+func testSchemaSelectionOnlySpecifiedSchemasForVersion(+ t *testing.T,+ pgVersion string,+ port string,+) {container, err := connectToPostgresContainer(pgVersion, port)assert.NoError(t, err)- defer func() {- if container.DB != nil {- container.DB.Close()- }- }()+ defer container.DB.Close()- _, err = container.DB.Exec(createAndFillTableQuery)+ _, err = container.DB.Exec(`+ DROP SCHEMA IF EXISTS schema_a CASCADE;+ DROP SCHEMA IF EXISTS schema_b CASCADE;+ CREATE SCHEMA schema_a;+ CREATE SCHEMA schema_b;++ CREATE TABLE public.public_table (id SERIAL PRIMARY KEY, data TEXT);+ CREATE TABLE schema_a.table_a (id SERIAL PRIMARY KEY, data TEXT);+ CREATE TABLE schema_b.table_b (id SERIAL PRIMARY KEY, data TEXT);++ INSERT INTO public.public_table (data) VALUES ('public_data');+ INSERT INTO schema_a.table_a (data) VALUES ('schema_a_data');+ INSERT INTO schema_b.table_b (data) VALUES ('schema_b_data');+ `)assert.NoError(t, err)+ defer func() {+ _, _ = container.DB.Exec(`+ DROP TABLE IF EXISTS public.public_table;+ DROP SCHEMA IF EXISTS schema_a CASCADE;+ DROP SCHEMA IF EXISTS schema_b CASCADE;+ `)+ }()+router := createTestRouter()user := users_testing.CreateTestUser(users_enums.UserRoleMember)- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)+ workspace := workspaces_testing.CreateTestWorkspace("Schema Test Workspace", user, router)storage := storages.CreateTestStorage(workspace.ID)- database := createDatabaseViaAPI(- t, router, "Test Database", workspace.ID,+ database := createDatabaseWithSchemasViaAPI(+ t, router, "Specific Schemas Database", workspace.ID,container.Host, container.Port,container.Username, container.Password, container.Database,+ []string{"public", "schema_a"},user.Token,)@@ -524,7 +866,7 @@ func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {backup := waitForBackupCompletion(t, router, database.ID, user.Token, 5*time.Minute)assert.Equal(t, backups.BackupStatusCompleted, backup.Status)- newDBName := "restoreddb"+ newDBName := "restored_specific_schemas_" + pgVersion_, err = container.DB.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS %s;", newDBName))assert.NoError(t, err)@@ -547,15 +889,35 @@ func testBackupRestoreForVersion(t *testing.T, pgVersion string, port string) {restore := waitForRestoreCompletion(t, router, backup.ID, user.Token, 5*time.Minute)assert.Equal(t, restores_enums.RestoreStatusCompleted, restore.Status)- var tableExists bool- err = newDB.Get(- &tableExists,- "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'test_data')",- )+ var publicTableExists bool+ err = newDB.Get(&publicTableExists, `+ SELECT EXISTS (+ SELECT FROM information_schema.tables+ WHERE table_schema = 'public' AND table_name = 'public_table'+ )+ `)assert.NoError(t, err)- assert.True(t, tableExists, "Table 'test_data' should exist in restored database")+ assert.True(t, publicTableExists, "public.public_table should exist (was included)")- verifyDataIntegrity(t, container.DB, newDB)+ var schemaATableExists bool+ err = newDB.Get(&schemaATableExists, `+ SELECT EXISTS (+ SELECT FROM information_schema.tables+ WHERE table_schema = 'schema_a' AND table_name = 'table_a'+ )+ `)+ assert.NoError(t, err)+ assert.True(t, schemaATableExists, "schema_a.table_a should exist (was included)")++ var schemaBTableExists bool+ err = newDB.Get(&schemaBTableExists, `+ SELECT EXISTS (+ SELECT FROM information_schema.tables+ WHERE table_schema = 'schema_b' AND table_name = 'table_b'+ )+ `)+ assert.NoError(t, err)+ assert.False(t, schemaBTableExists, "schema_b.table_b should NOT exist (was excluded)")err = os.Remove(filepath.Join(config.GetEnv().DataFolder, backup.ID.String()))if err != nil {@@ -852,14 +1214,41 @@ func createRestoreViaAPI(password string,database string,token string,+) {+ createRestoreWithOptionsViaAPI(+ t,+ router,+ backupID,+ host,+ port,+ username,+ password,+ database,+ false,+ token,+ )+}++func createRestoreWithOptionsViaAPI(+ t *testing.T,+ router *gin.Engine,+ backupID uuid.UUID,+ host string,+ port int,+ username string,+ password string,+ database string,+ isExcludeExtensions bool,+ token string,) {request := restores.RestoreBackupRequest{PostgresqlDatabase: &pgtypes.PostgresqlDatabase{- Host: host,- Port: port,- Username: username,- Password: password,- Database: &database,+ Host: host,+ Port: port,+ Username: username,+ Password: password,+ Database: &database,+ IsExcludeExtensions: isExcludeExtensions,},}diff --git a/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts b/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.tsindex 0e0fe8d1..6f14fbc8 100644--- a/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts+++ b/frontend/src/entity/databases/model/postgresql/PostgresqlDatabase.ts@@ -14,4 +14,7 @@ export interface PostgresqlDatabase {// backup settingsincludeSchemas?: string[];++ // restore settings (not saved to DB)+ isExcludeExtensions?: boolean;}diff --git a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsxindex 74dcaad2..5562b116 100644--- a/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx+++ b/frontend/src/features/databases/ui/edit/EditDatabaseSpecificDataComponent.tsx@@ -1,5 +1,5 @@-import { CopyOutlined, DownOutlined, UpOutlined } from '@ant-design/icons';-import { App, Button, Input, InputNumber, Select, Switch } from 'antd';+import { CopyOutlined, DownOutlined, InfoCircleOutlined, UpOutlined } from '@ant-design/icons';+import { App, Button, Checkbox, Input, InputNumber, Select, Switch, Tooltip } from 'antd';import { useEffect, useState } from 'react';import { type Database, DatabaseType, databaseApi } from '../../../../entity/databases';@@ -20,6 +20,7 @@ interface Props {onSaved: (database: Database) => void;isShowDbName?: boolean;+ isRestoreMode?: boolean;}export const EditDatabaseSpecificDataComponent = ({@@ -35,6 +36,7 @@ export const EditDatabaseSpecificDataComponent = ({isSaveToApi,onSaved,isShowDbName = true,+ isRestoreMode = false,}: Props) => {const { message } = App.useApp();@@ -45,7 +47,8 @@ export const EditDatabaseSpecificDataComponent = ({const [isTestingConnection, setIsTestingConnection] = useState(false);const [isConnectionFailed, setIsConnectionFailed] = useState(false);- const hasAdvancedValues = !!database.postgresql?.includeSchemas?.length;+ const hasAdvancedValues =+ !!database.postgresql?.includeSchemas?.length || !!database.postgresql?.isExcludeExtensions;const [isShowAdvanced, setShowAdvanced] = useState(hasAdvancedValues);const [hasAutoAddedPublicSchema, setHasAutoAddedPublicSchema] = useState(false);@@ -366,25 +369,60 @@ export const EditDatabaseSpecificDataComponent = ({</div>{isShowAdvanced && (- <div className="mb-1 flex w-full items-center">- <div className="min-w-[150px]">Include schemas</div>- <Select- mode="tags"- value={editingDatabase.postgresql?.includeSchemas || []}- onChange={(values) => {- if (!editingDatabase.postgresql) return;+ <>+ {!isRestoreMode && (+ <div className="mb-1 flex w-full items-center">+ <div className="min-w-[150px]">Include schemas</div>+ <Select+ mode="tags"+ value={editingDatabase.postgresql?.includeSchemas || []}+ onChange={(values) => {+ if (!editingDatabase.postgresql) return;++ setEditingDatabase({+ ...editingDatabase,+ postgresql: { ...editingDatabase.postgresql, includeSchemas: values },+ });+ }}+ size="small"+ className="max-w-[200px] grow"+ placeholder="All schemas (default)"+ tokenSeparators={[',']}+ />+ </div>+ )}- setEditingDatabase({- ...editingDatabase,- postgresql: { ...editingDatabase.postgresql, includeSchemas: values },- });- }}- size="small"- className="max-w-[200px] grow"- placeholder="All schemas (default)"- tokenSeparators={[',']}- />- </div>+ {isRestoreMode && (+ <div className="mb-1 flex w-full items-center">+ <div className="min-w-[150px]">Exclude extensions</div>+ <div className="flex items-center">+ <Checkbox+ checked={editingDatabase.postgresql?.isExcludeExtensions || false}+ onChange={(e) => {+ if (!editingDatabase.postgresql) return;++ setEditingDatabase({+ ...editingDatabase,+ postgresql: {+ ...editingDatabase.postgresql,+ isExcludeExtensions: e.target.checked,+ },+ });+ }}+ >+ Skip extensions+ </Checkbox>++ <Tooltip+ className="cursor-pointer"+ title="Skip restoring extension definitions (CREATE EXTENSION statements). Enable this if you're restoring to a managed PostgreSQL service where extensions are managed by the provider."+ >+ <InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />+ </Tooltip>+ </div>+ </div>+ )}+ </>)}</>)}diff --git a/frontend/src/features/restores/ui/RestoresComponent.tsx b/frontend/src/features/restores/ui/RestoresComponent.tsxindex 6631ed03..3be30e73 100644--- a/frontend/src/features/restores/ui/RestoresComponent.tsx+++ b/frontend/src/features/restores/ui/RestoresComponent.tsx@@ -111,6 +111,7 @@ export const RestoresComponent = ({ database, backup }: Props) => {setEditingDatabase({ ...database });restore(database);}}+ isRestoreMode={true}/></>);@@ -245,6 +246,13 @@ export const RestoresComponent = ({ database, backup }: Props) => {</Button>}>+ {showingRestoreError.failMessage?.includes('must be owner of extension') && (+ <div className="mb-4 rounded border border-yellow-300 bg-yellow-50 p-3 text-sm dark:border-yellow-600 dark:bg-yellow-900/30">+ <strong>💡 Tip:</strong> This error typically occurs when restoring to managed+ PostgreSQL services (like Yandex Cloud, AWS RDS or similar). Try enabling{' '}+ <strong>"Exclude extensions"</strong> in Advanced settings before restoring.+ </div>+ )}<div className="overflow-y-auto text-sm whitespace-pre-wrap" style={{ height: '400px' }}>{showingRestoreError.failMessage}</div>