PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
import { CopyOutlined, InfoCircleOutlined } from '@ant-design/icons';
import { App, Button, Checkbox, Input, InputNumber, Select, Tooltip } from 'antd';
import { useEffect, useState } from 'react';
import { Trans, useTranslation } from 'react-i18next';
import {
type Database,
POSTGRESQL_SHORT_NAME,
POSTGRES_SSL_MODE_LABEL_KEYS,
PostgresSslMode,
type PostgresqlLogicalDatabase,
databaseApi,
hasStoredSshTunnelSecretsForAuthType,
isSshTunnelReadyToTest,
} from '../../../../entity/databases';
import { ConnectionStringParser } from '../../../../entity/databases/model/postgresql/ConnectionStringParser';
import {
getWebsitePageUrl,
translateApiError,
translateLocalizedText,
useLocale,
} from '../../../../shared/i18n';
import { NAME_LIST_TOKEN_SEPARATORS, normalizeNameList } from '../../../../shared/lib';
import { ClipboardHelper } from '../../../../shared/lib/ClipboardHelper';
import { ToastHelper } from '../../../../shared/toast';
import {
AdvancedSettingsToggleComponent,
ClipboardPasteModalComponent,
} from '../../../../shared/ui';
import { EditSshTunnelComponent } from './EditSshTunnelComponent';
interface Props {
database: Database;
isShowCancelButton?: boolean;
onCancel: () => void;
isShowBackButton: boolean;
onBack: () => void;
saveButtonText?: string;
isSaveToApi: boolean;
onSaved: (database: Database) => void;
isShowDbName?: boolean;
isRestoreMode?: boolean;
}
const IPV4_PATTERN = /^\d{1,3}(\.\d{1,3}){3}$/;
const deriveSslModeFromHost = (rawHost: string): PostgresSslMode | null => {
const trimmed = rawHost.trim().toLowerCase();
if (trimmed.startsWith('https://')) return PostgresSslMode.Require;
if (trimmed.startsWith('http://')) return PostgresSslMode.Disable;
const bareHost = trimmed.split(':')[0];
if (bareHost === 'localhost' || IPV4_PATTERN.test(bareHost)) {
return PostgresSslMode.Disable;
}
return null;
};
const applySslMode = (
postgresqlLogical: PostgresqlLogicalDatabase,
sslMode: PostgresSslMode,
): PostgresqlLogicalDatabase => {
if (sslMode === PostgresSslMode.Disable) {
return { ...postgresqlLogical, sslMode, sslClientCert: '', sslClientKey: '', sslRootCert: '' };
}
return { ...postgresqlLogical, sslMode };
};
export const EditPostgreSqlLogicalSpecificDataComponent = ({
database,
isShowCancelButton,
onCancel,
isShowBackButton,
onBack,
saveButtonText,
isSaveToApi,
onSaved,
isShowDbName = true,
isRestoreMode = false,
}: Props) => {
const { t } = useTranslation();
const { locale } = useLocale();
const { message } = App.useApp();
const [editingDatabase, setEditingDatabase] = useState<Database>({ ...database });
const [isSaving, setIsSaving] = useState(false);
const [isConnectionTested, setIsConnectionTested] = useState(false);
const [isTestingConnection, setIsTestingConnection] = useState(false);
const [isConnectionFailed, setIsConnectionFailed] = useState(false);
const hasAdvancedValues =
!!database.postgresqlLogical?.sslClientCert ||
!!database.postgresqlLogical?.sslRootCert ||
!!database.postgresqlLogical?.sshTunnel?.isEnabled ||
(isRestoreMode
? !!database.postgresqlLogical?.isExcludeExtensions ||
!!database.postgresqlLogical?.isRestoreOwnership ||
!!database.postgresqlLogical?.isRestorePrivileges
: !!database.postgresqlLogical?.includeSchemas?.length ||
!!database.postgresqlLogical?.excludeTables?.length ||
!!database.postgresqlLogical?.excludeTableData?.length ||
!!database.postgresqlLogical?.isSkipUserMappings);
const [isShowAdvanced, setShowAdvanced] = useState(hasAdvancedValues);
const [hasAutoAddedPublicSchema, setHasAutoAddedPublicSchema] = useState(false);
const [hasUserChosenSslMode, setHasUserChosenSslMode] = useState(!!database.id);
const [isReplacingCerts, setIsReplacingCerts] = useState(false);
const [isShowPasteModal, setIsShowPasteModal] = useState(false);
const applyConnectionString = (text: string) => {
const trimmedText = text.trim();
if (!trimmedText) {
message.error(t('databases.edit.clipboardEmpty'));
return;
}
const result = ConnectionStringParser.parse(trimmedText);
if ('error' in result) {
message.error(translateLocalizedText(result.error, t));
return;
}
if (!editingDatabase?.postgresqlLogical) return;
const updatedDatabase: Database = {
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
host: result.host,
port: result.port,
username: result.username,
password: result.password,
database: result.database,
sslMode: result.sslMode,
cpuCount: 1,
},
};
setHasUserChosenSslMode(true);
setEditingDatabase(autoAddPublicSchemaForSupabase(updatedDatabase));
setIsConnectionTested(false);
message.success(t('databases.edit.connectionStringParsed'));
};
const parseFromClipboard = async () => {
if (!ClipboardHelper.isClipboardApiAvailable()) {
setIsShowPasteModal(true);
return;
}
try {
const text = await ClipboardHelper.readFromClipboard();
applyConnectionString(text);
} catch {
message.error(t('databases.edit.clipboardReadFailed'));
}
};
const autoAddPublicSchemaForSupabase = (updatedDatabase: Database): Database => {
if (hasAutoAddedPublicSchema) return updatedDatabase;
const host = updatedDatabase.postgresqlLogical?.host || '';
const username = updatedDatabase.postgresqlLogical?.username || '';
const isSupabase = host.includes('supabase') || username.includes('supabase');
if (isSupabase && updatedDatabase.postgresqlLogical) {
setHasAutoAddedPublicSchema(true);
const currentSchemas = updatedDatabase.postgresqlLogical.includeSchemas || [];
if (!currentSchemas.includes('public')) {
return {
...updatedDatabase,
postgresqlLogical: {
...updatedDatabase.postgresqlLogical,
// eslint-disable-next-line i18next/no-literal-string -- PostgreSQL schema name
includeSchemas: ['public', ...currentSchemas],
},
};
}
}
return updatedDatabase;
};
const testConnection = async () => {
if (!editingDatabase?.postgresqlLogical) return;
setIsTestingConnection(true);
setIsConnectionFailed(false);
const trimmedDatabase = {
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
password: editingDatabase.postgresqlLogical.password?.trim(),
},
};
try {
await databaseApi.testDatabaseConnectionDirect(trimmedDatabase);
setIsConnectionTested(true);
ToastHelper.showToast({
title: t('databases.edit.connectionTestPassed.title'),
description: t('databases.edit.connectionTestPassed.description'),
});
} catch (e) {
setIsConnectionFailed(true);
alert(translateApiError(e, t));
}
setIsTestingConnection(false);
};
const saveDatabase = async () => {
if (!editingDatabase?.postgresqlLogical) return;
const trimmedDatabase = {
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
password: editingDatabase.postgresqlLogical.password?.trim(),
},
};
if (isSaveToApi) {
setIsSaving(true);
try {
await databaseApi.updateDatabase(trimmedDatabase);
} catch (e) {
alert(translateApiError(e, t));
}
setIsSaving(false);
}
onSaved(trimmedDatabase);
};
const updatePostgresqlCert = (
field: 'sslClientCert' | 'sslClientKey' | 'sslRootCert',
value: string,
) => {
if (!editingDatabase?.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: { ...editingDatabase.postgresqlLogical, [field]: value },
});
setIsConnectionTested(false);
};
const startReplacingCerts = () => {
if (!editingDatabase?.postgresqlLogical) return;
setIsReplacingCerts(true);
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
sslClientCert: '',
sslClientKey: '',
sslRootCert: '',
},
});
setIsConnectionTested(false);
};
useEffect(() => {
setIsSaving(false);
setIsConnectionTested(false);
setIsTestingConnection(false);
setIsConnectionFailed(false);
setIsReplacingCerts(false);
setHasUserChosenSslMode(!!database.id);
setEditingDatabase({ ...database });
}, [database]);
const renderFooter = (footerContent?: React.ReactNode) => (
<div className="mt-5 flex">
{isShowCancelButton && (
<Button className="mr-1" danger ghost onClick={() => onCancel()}>
{t('common.actions.cancel')}
</Button>
)}
{isShowBackButton && (
<Button className="mr-auto" type="primary" ghost onClick={() => onBack()}>
{t('common.actions.back')}
</Button>
)}
{footerContent}
</div>
);
const renderSslCertSection = () => {
const sslMode = editingDatabase.postgresqlLogical?.sslMode ?? PostgresSslMode.Disable;
if (sslMode === PostgresSslMode.Disable) return null;
const hadSslCert = !!database.postgresqlLogical?.sslClientCert;
if (hadSslCert && !isReplacingCerts) {
return (
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.clientCertificate')}</div>
<div className="flex items-center">
<span className="mr-3">*************</span>
<Button size="small" onClick={startReplacingCerts}>
{t('databases.actions.replace')}
</Button>
</div>
</div>
);
}
return (
<>
<div className="mb-1 flex w-full items-start">
<div className="min-w-[150px] pr-2">{t('databases.fields.clientCertificate')}</div>
<Input.TextArea
value={editingDatabase.postgresqlLogical?.sslClientCert || ''}
onChange={(e) => updatePostgresqlCert('sslClientCert', e.target.value)}
size="small"
className="max-w-[300px] grow"
// eslint-disable-next-line i18next/no-literal-string -- PEM format example, not copy
placeholder="-----BEGIN CERTIFICATE-----"
autoSize={{ minRows: 2, maxRows: 5 }}
/>
</div>
<div className="mb-1 flex w-full items-start">
<div className="min-w-[150px] pr-2">{t('databases.fields.clientKey')}</div>
<Input.TextArea
value={editingDatabase.postgresqlLogical?.sslClientKey || ''}
onChange={(e) => updatePostgresqlCert('sslClientKey', e.target.value)}
size="small"
className="max-w-[300px] grow"
// eslint-disable-next-line i18next/no-literal-string -- PEM format example, not copy
placeholder="-----BEGIN PRIVATE KEY-----"
autoSize={{ minRows: 2, maxRows: 5 }}
/>
</div>
<div className="mb-1 flex w-full items-start">
<div className="flex min-w-[150px] items-center pr-2">
<span>{t('databases.fields.serverCaCertificate')}</span>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.serverCaCertificateTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
<Input.TextArea
value={editingDatabase.postgresqlLogical?.sslRootCert || ''}
onChange={(e) => updatePostgresqlCert('sslRootCert', e.target.value)}
size="small"
className="max-w-[300px] grow"
// eslint-disable-next-line i18next/no-literal-string -- PEM format example, not copy
placeholder="-----BEGIN CERTIFICATE-----"
autoSize={{ minRows: 2, maxRows: 5 }}
/>
</div>
</>
);
};
const renderPgDumpForm = () => {
let isAllFieldsFilled = true;
if (!editingDatabase.postgresqlLogical?.host) isAllFieldsFilled = false;
if (!editingDatabase.postgresqlLogical?.port) isAllFieldsFilled = false;
if (!editingDatabase.postgresqlLogical?.username) isAllFieldsFilled = false;
if (!editingDatabase.id && !editingDatabase.postgresqlLogical?.password)
isAllFieldsFilled = false;
if (!editingDatabase.postgresqlLogical?.database) isAllFieldsFilled = false;
if (!isSshTunnelReadyToTest(editingDatabase.postgresqlLogical?.sshTunnel, hasStoredSshSecrets))
isAllFieldsFilled = false;
const isTunnelEnabled = !!editingDatabase.postgresqlLogical?.sshTunnel?.isEnabled;
// Behind a tunnel a loopback address means "on the bastion", which is the documented setup
// rather than the mistake this hint warns about.
const isLocalhostDb =
!isTunnelEnabled &&
(editingDatabase.postgresqlLogical?.host?.includes('localhost') ||
editingDatabase.postgresqlLogical?.host?.includes('127.0.0.1'));
const isSupabaseDb =
editingDatabase.postgresqlLogical?.host?.includes('supabase') ||
editingDatabase.postgresqlLogical?.username?.includes('supabase');
return (
<>
<div className="mb-3 flex">
<div className="min-w-[150px] pr-2" />
<div
className="cursor-pointer text-sm text-gray-600 transition-colors hover:text-gray-900 dark:text-gray-400 dark:hover:text-gray-200"
onClick={parseFromClipboard}
>
<CopyOutlined className="mr-1" />
{t('databases.edit.parseFromClipboard')}
</div>
</div>
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('common.fields.host')}</div>
<Input
value={editingDatabase.postgresqlLogical?.host}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
const rawHost = e.target.value;
const basePostgresql = {
...editingDatabase.postgresqlLogical,
host: rawHost.trim().replace('https://', '').replace('http://', ''),
};
const isHttpsHost = rawHost.trim().toLowerCase().startsWith('https://');
const currentSslMode = basePostgresql.sslMode ?? PostgresSslMode.Disable;
let derivedSslMode: PostgresSslMode | null = null;
if (hasUserChosenSslMode) {
if (isHttpsHost && currentSslMode === PostgresSslMode.Disable) {
derivedSslMode = PostgresSslMode.Require;
}
} else {
derivedSslMode = deriveSslModeFromHost(rawHost);
}
const updatedDatabase = {
...editingDatabase,
postgresqlLogical:
derivedSslMode !== null
? applySslMode(basePostgresql, derivedSslMode)
: basePostgresql,
};
setEditingDatabase(autoAddPublicSchemaForSupabase(updatedDatabase));
setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.placeholders.host', { engine: POSTGRESQL_SHORT_NAME })}
/>
</div>
{isLocalhostDb && (
<div className="mb-1 flex">
<div className="min-w-[150px] pr-2" />
<div className="max-w-[200px] text-xs text-gray-500 dark:text-gray-400">
<Trans
i18nKey="databases.edit.localhostHint"
components={{
docsLink: (
<a
href={getWebsitePageUrl('faqLocalhost', locale)}
target="_blank"
rel="noreferrer"
className="!text-blue-600 dark:!text-blue-400"
/>
),
}}
/>
</div>
</div>
)}
{isSupabaseDb && (
<div className="mb-1 flex">
<div className="min-w-[150px] pr-2" />
<div className="max-w-[200px] text-xs text-gray-500 dark:text-gray-400">
<Trans
i18nKey="databases.edit.postgresql.supabaseHint"
components={{
docsLink: (
<a
href={getWebsitePageUrl('faqSupabase', locale)}
target="_blank"
rel="noreferrer"
className="!text-blue-600 dark:!text-blue-400"
/>
),
}}
/>
</div>
</div>
)}
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('common.fields.port')}</div>
<InputNumber
type="number"
value={editingDatabase.postgresqlLogical?.port}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical || e === null) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: { ...editingDatabase.postgresqlLogical, port: e },
});
setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.placeholders.port', { engine: POSTGRESQL_SHORT_NAME })}
/>
</div>
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('common.fields.username')}</div>
<Input
value={editingDatabase.postgresqlLogical?.username}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
const updatedDatabase = {
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
username: e.target.value.trim(),
},
};
setEditingDatabase(autoAddPublicSchemaForSupabase(updatedDatabase));
setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.placeholders.username', {
engine: POSTGRESQL_SHORT_NAME,
})}
/>
</div>
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('common.fields.password')}</div>
<Input.Password
value={editingDatabase.postgresqlLogical?.password}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
password: e.target.value,
},
});
setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.placeholders.password', {
engine: POSTGRESQL_SHORT_NAME,
})}
autoComplete="off"
data-1p-ignore
data-lpignore="true"
data-form-type="other"
/>
</div>
{isShowDbName && (
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.databaseName')}</div>
<Input
value={editingDatabase.postgresqlLogical?.database}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
database: e.target.value.trim(),
},
});
setIsConnectionTested(false);
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.placeholders.databaseName', {
engine: POSTGRESQL_SHORT_NAME,
})}
/>
</div>
)}
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.sslMode')}</div>
<Select
value={editingDatabase.postgresqlLogical?.sslMode ?? PostgresSslMode.Disable}
onChange={(value: PostgresSslMode) => {
if (!editingDatabase.postgresqlLogical) return;
setHasUserChosenSslMode(true);
setEditingDatabase({
...editingDatabase,
postgresqlLogical: applySslMode(editingDatabase.postgresqlLogical, value),
});
setIsConnectionTested(false);
}}
options={Object.values(PostgresSslMode).map((sslMode) => ({
label: t(POSTGRES_SSL_MODE_LABEL_KEYS[sslMode]),
value: sslMode,
}))}
size="small"
className="max-w-[200px] grow"
/>
</div>
{isRestoreMode && (
<div className="mb-5 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.cpuCount')}</div>
<div className="flex items-center">
<InputNumber
min={1}
max={128}
value={editingDatabase.postgresqlLogical?.cpuCount}
onChange={(value) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
cpuCount: value || 1,
},
});
setIsConnectionTested(false);
}}
size="small"
className="max-w-[75px] grow"
/>
<Tooltip className="cursor-pointer" title={t('databases.edit.cpuCountTooltip')}>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
</div>
)}
<AdvancedSettingsToggleComponent
label={t('databases.edit.advancedSettings')}
isShowAdvanced={isShowAdvanced}
onToggle={() => setShowAdvanced(!isShowAdvanced)}
/>
{isShowAdvanced && (
<>
<EditSshTunnelComponent
sshTunnel={editingDatabase.postgresqlLogical?.sshTunnel}
hasStoredSecrets={hasStoredSshSecrets}
onChange={(sshTunnel) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: { ...editingDatabase.postgresqlLogical, sshTunnel },
});
setIsConnectionTested(false);
}}
/>
{!isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.includeSchemas')}</div>
<Select
mode="tags"
value={editingDatabase.postgresqlLogical?.includeSchemas || []}
onChange={(values) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
includeSchemas: normalizeNameList(values),
},
});
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.postgresql.includeSchemasPlaceholder')}
tokenSeparators={NAME_LIST_TOKEN_SEPARATORS}
/>
</div>
)}
{!isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.excludeWholeTables')}</div>
<Select
mode="tags"
value={editingDatabase.postgresqlLogical?.excludeTables || []}
onChange={(values) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
excludeTables: normalizeNameList(values),
},
});
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.excludeTablesPlaceholder')}
tokenSeparators={NAME_LIST_TOKEN_SEPARATORS}
/>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.postgresql.excludeTablesTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
)}
{!isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="min-w-[150px] pr-2">{t('databases.fields.excludeTableData')}</div>
<Select
mode="tags"
value={editingDatabase.postgresqlLogical?.excludeTableData || []}
onChange={(values) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
excludeTableData: normalizeNameList(values),
},
});
}}
size="small"
className="max-w-[200px] grow"
placeholder={t('databases.edit.postgresql.excludeTableDataPlaceholder')}
tokenSeparators={NAME_LIST_TOKEN_SEPARATORS}
/>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.postgresql.excludeTableDataTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
)}
{!isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="flex min-w-[150px] items-center pr-2">
<span>{t('databases.fields.skipUserMappings')}</span>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.postgresql.skipUserMappingsTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
<Checkbox
checked={editingDatabase.postgresqlLogical?.isSkipUserMappings || false}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
isSkipUserMappings: e.target.checked,
},
});
}}
/>
</div>
)}
{isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="flex min-w-[150px] items-center pr-2">
<span>{t('databases.fields.excludeExtensions')}</span>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.postgresql.excludeExtensionsTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
<Checkbox
checked={editingDatabase.postgresqlLogical?.isExcludeExtensions || false}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
isExcludeExtensions: e.target.checked,
},
});
}}
/>
</div>
)}
{isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="flex min-w-[150px] items-center pr-2">
<span>{t('databases.fields.restoreOwnership')}</span>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.postgresql.restoreOwnershipTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
<Checkbox
checked={editingDatabase.postgresqlLogical?.isRestoreOwnership || false}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
isRestoreOwnership: e.target.checked,
},
});
}}
/>
</div>
)}
{isRestoreMode && (
<div className="mb-1 flex w-full items-center">
<div className="flex min-w-[150px] items-center pr-2">
<span>{t('databases.fields.restorePrivileges')}</span>
<Tooltip
className="cursor-pointer"
title={t('databases.edit.postgresql.restorePrivilegesTooltip')}
>
<InfoCircleOutlined className="ml-2" style={{ color: 'gray' }} />
</Tooltip>
</div>
<Checkbox
checked={editingDatabase.postgresqlLogical?.isRestorePrivileges || false}
onChange={(e) => {
if (!editingDatabase.postgresqlLogical) return;
setEditingDatabase({
...editingDatabase,
postgresqlLogical: {
...editingDatabase.postgresqlLogical,
isRestorePrivileges: e.target.checked,
},
});
}}
/>
</div>
)}
{renderSslCertSection()}
</>
)}
{renderFooter(
<>
{!isConnectionTested && (
<Button
type="primary"
onClick={() => testConnection()}
loading={isTestingConnection}
disabled={!isAllFieldsFilled}
className="mr-5"
>
{t('databases.actions.testConnection')}
</Button>
)}
{isConnectionTested && (
<Button
type="primary"
onClick={() => saveDatabase()}
loading={isSaving}
disabled={!isAllFieldsFilled}
className="mr-5"
>
{saveButtonText || t('common.actions.save')}
</Button>
)}
</>,
)}
{isConnectionFailed && (
<div className="mt-3 text-sm text-gray-500 dark:text-gray-400">
{t('databases.edit.ipWhitelistHint')}
</div>
)}
</>
);
};
const hasStoredSshSecrets = hasStoredSshTunnelSecretsForAuthType(
database.postgresqlLogical?.sshTunnel,
editingDatabase.postgresqlLogical?.sshTunnel?.authType,
database.id,
);
return (
<div>
{renderPgDumpForm()}
<ClipboardPasteModalComponent
open={isShowPasteModal}
onSubmit={(text) => {
setIsShowPasteModal(false);
applyConnectionString(text);
}}
onCancel={() => setIsShowPasteModal(false)}
/>
</div>
);
};