ydb-embedded-ui 20.2.0 → 20.3.0

package/src/containers/Tenant/TopicFormDialog/i18n/en.json

@@ -0,0 +1,58 @@
+{
+  "action_cancel": "Cancel",
+  "action_create": "Create",
+  "action_update": "Update",
+
+  "title_topic-create": "Create topic",
+  "title_topic-edit": "Edit topic",
+  "title_topic-parameters": "Parameters",
+  "title_auto-partitioning-settings": "Advanced settings",
+
+  "field_name": "Name",
+  "field_shard-write-quota": "Shard throughput",
+  "field_auto-partitioning": "Autopartitioning",
+  "field_shards": "Shards",
+  "field_auto-partitioning-mode": "Autopartitioning mode",
+  "field_auto-partitioning-stabilization-window": "Stabilization period",
+  "field_auto-partitioning-up-utilization": "Upper utilization limit",
+
+  "context_field-name": "Use slash-separated path segments. Each segment may contain Latin letters (A-Z, a-z), numbers (0-9), and special characters: ., -, _. Maximum segment length is 255 characters.",
+  "context_shards-write-quota": "The maximum allowed write speed per partition. [Read more](https://ydb.tech/docs/en/concepts/datamodel/topic#partitioning) about partition throughput",
+  "context_throughput-info": "Total throughput: up to {{speed}} (calculated using the formula: partition throughput * number of partitions)",
+  "context_throughput-info-range": "Total throughput: from {{from}} to {{to}} (calculated using the formula: partition throughput * number of partitions)",
+  "context_auto-partitioning": "Dynamic scaling of the topic depending on the write speed. [Documentation](https://ydb.tech/docs/en/concepts/datamodel/topic#autopartitioning)",
+  "context_auto-partitioning-mode-disabled": "Autopartitioning cannot be disabled",
+  "context_shards": "Number of [partitions](https://ydb.tech/docs/en/concepts/datamodel/topic#partitioning) in the topic",
+  "context_shards-info": "The number of shards cannot be reduced",
+  "context_auto-partitioning-mode": "Autopartitioning mode for the topic. [Read more](https://ydb.tech/docs/en/concepts/datamodel/topic#autopartitioning_strategies) ",
+  "context_auto-partitioning-stabilization-window": "The period of time after a load change when the number of partitions will change",
+  "context_auto-partitioning-up-utilization": "The threshold at which the number of partitions increases",
+
+  "confirm_auto-partitioning-message": "The Kafka protocol does not support topic autopartitioning. If you enable autopartitioning, you will not be able to work with the topics you create using the Kafka protocol. You cannot disable autopartitioning for a specific topic.",
+
+  "value_auto-partitioning-scale-up": "Scale up",
+  "value_auto-partitioning-paused": "Paused",
+  "value_min": "Minimum",
+  "value_max": "Maximum",
+  "value_seconds": "seconds",
+  "value_rows": "rows",
+
+  "alert_create-success": "Topic created",
+  "alert_create-error": "Failed to create topic",
+  "alert_update-success": "Topic updated",
+  "alert_update-error": "Failed to update topic",
+
+  "error_load-topic": "Unable to load topic settings",
+  "error_topic-path-required": "Topic path is not specified",
+  "error_required": "Required field",
+  "error_number": "Value must be a number",
+  "error_int": "Value must be an integer",
+  "error_lowercase": "Value must be lowercase",
+  "error_name-regex": "Use slash-separated path segments. Each segment may contain Latin letters (A-Z, a-z), numbers (0-9), and special characters: ., -, _. Maximum segment length is 255 characters.",
+  "error_min-length": "Value can't be shorter than {{count}} characters",
+  "error_max-length": "Value can't be longer than {{count}} characters",
+  "error_min-number": "Value must be an integer no less than {{count}}",
+  "error_max-number": "Value must not be greater than {{count}}",
+  "error_less-than-number": "This value must be an integer less than {{count}}",
+  "error_more-than-number": "This value must be an integer greater than {{count}}"
+}

package/src/containers/Tenant/TopicFormDialog/i18n/index.ts

@@ -0,0 +1,7 @@
+import {registerKeysets} from '../../../../utils/i18n';
+
+import en from './en.json';
+
+const COMPONENT = 'ydb-topic-form-dialog';
+
+export default registerKeysets(COMPONENT, {en});

package/src/containers/Tenant/TopicFormDialog/utils.ts

@@ -0,0 +1,139 @@
+import type {TopicFormValues} from '../../../store/reducers/topic/utils';
+import {AutoPartitioningStrategy} from '../../../store/reducers/topic/utils';
+import {UNBREAKABLE_GAP} from '../../../utils/constants';
+
+export const TOPIC_FORM_DIALOG = 'topic-form-dialog';
+
+const KILOBYTE = 1024;
+const MEGABYTE = KILOBYTE * 1024;
+
+export const DEFAULT_TOPIC_FORM_VALUES: TopicFormValues = {
+    shards: 1,
+    writeQuotaBytes: 1024 * 1024,
+    autoPartitioning: {
+        enabled: false,
+        mode: AutoPartitioningStrategy.ScaleUp,
+        minPartitions: 1,
+        maxPartitions: 2,
+        stabilizationWindow: 300,
+        upUtilization: 90,
+    },
+};
+
+export function acceptNumber(value: string) {
+    return value === '' || (/^[0-9]+$/.test(value) && Number(value) <= Number.MAX_SAFE_INTEGER);
+}
+
+export function parseNumberInput(value: string): number {
+    return value ? Number.parseInt(value, 10) : NaN;
+}
+
+export function formatNumberInput(value: number | undefined): string {
+    return typeof value === 'number' && !Number.isNaN(value) ? value.toString() : '';
+}
+
+export function formatBandwidthBytes(value: number | undefined) {
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return '';
+    }
+
+    if (value >= MEGABYTE) {
+        return `${value / MEGABYTE}${UNBREAKABLE_GAP}MB/s`;
+    }
+
+    if (value >= KILOBYTE) {
+        return `${value / KILOBYTE}${UNBREAKABLE_GAP}KB/s`;
+    }
+
+    return `${value}${UNBREAKABLE_GAP}byte/s`;
+}
+
+export function formatWriteQuotaSelectValue(value: number | undefined) {
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return '';
+    }
+
+    if (value >= MEGABYTE && value % MEGABYTE === 0) {
+        return `${value / MEGABYTE}${UNBREAKABLE_GAP}MB/s`;
+    }
+
+    if (value >= KILOBYTE && value % KILOBYTE === 0) {
+        return `${value / KILOBYTE}${UNBREAKABLE_GAP}KB/s`;
+    }
+
+    return `${value}${UNBREAKABLE_GAP}byte/s`;
+}
+
+function normalizePath(path: string) {
+    return path.replace(/^\/+|\/+$/g, '');
+}
+
+function getRelativePath(path: string, databaseFullPath: string): string | undefined {
+    const normalizedPath = normalizePath(path);
+    const normalizedDatabase = normalizePath(databaseFullPath);
+
+    if (!normalizedPath || normalizedPath === normalizedDatabase) {
+        return undefined;
+    }
+
+    if (normalizedPath.startsWith(`${normalizedDatabase}/`)) {
+        return normalizedPath.slice(normalizedDatabase.length + 1) || undefined;
+    }
+
+    return normalizedPath;
+}
+
+function splitTopicPath(topicPath: string, databaseFullPath: string) {
+    const relativePath = getRelativePath(topicPath, databaseFullPath);
+    const pathSegments = relativePath?.split('/').filter(Boolean) ?? [];
+    const name = pathSegments.pop() ?? '';
+    const path = pathSegments.join('/');
+
+    return {path: path || undefined, name};
+}
+
+export function buildFullTopicPath(formData: TopicFormValues, databaseFullPath: string) {
+    const databasePath = databaseFullPath.startsWith('/')
+        ? databaseFullPath
+        : `/${databaseFullPath}`;
+    const relativeTopicPath = [formData.path, formData.name].filter(Boolean).join('/');
+
+    return relativeTopicPath ? `${databasePath}/${relativeTopicPath}` : databasePath;
+}
+
+export function getCreateTopicInitialValues({
+    databaseFullPath,
+    parentPath,
+}: {
+    databaseFullPath: string;
+    parentPath?: string;
+}): TopicFormValues {
+    return {
+        ...DEFAULT_TOPIC_FORM_VALUES,
+        path: parentPath ? getRelativePath(parentPath, databaseFullPath) : undefined,
+        autoPartitioning: {...DEFAULT_TOPIC_FORM_VALUES.autoPartitioning},
+    };
+}
+
+export function getUpdateTopicInitialValues({
+    databaseFullPath,
+    formData,
+    topicPath,
+}: {
+    databaseFullPath: string;
+    formData: TopicFormValues;
+    topicPath: string;
+}): TopicFormValues {
+    const topicPathData = splitTopicPath(topicPath, databaseFullPath);
+
+    return {
+        ...DEFAULT_TOPIC_FORM_VALUES,
+        ...formData,
+        path: topicPathData.path,
+        name: topicPathData.name || formData.name,
+        autoPartitioning: {
+            ...DEFAULT_TOPIC_FORM_VALUES.autoPartitioning,
+            ...formData.autoPartitioning,
+        },
+    };
+}

package/src/containers/Tenant/TopicFormDialog/validation.ts

@@ -0,0 +1,134 @@
+import {z} from 'zod';
+
+import type {TopicFormValues} from '../../../store/reducers/topic/utils';
+import {isValidEntityPath} from '../utils/pathSegmentValidation';
+
+import i18n from './i18n';
+
+const MIN_ONE_MESSAGE = i18n('error_min-number', {count: 1});
+const MAX_HUNDRED_MESSAGE = i18n('error_max-number', {count: 100});
+const REQUIRED_MESSAGE = i18n('error_required');
+const NUMBER_MESSAGE = i18n('error_number');
+
+const getRequiredNumberError = (issue: {input?: unknown}) => {
+    return issue.input === undefined ? REQUIRED_MESSAGE : NUMBER_MESSAGE;
+};
+
+const addIssue = (ctx: z.RefinementCtx, path: Array<string | number>, message: string) => {
+    ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path,
+        message,
+    });
+};
+
+const requiredNumber = (schema?: z.ZodNumber) =>
+    z.preprocess(
+        (val) => (typeof val === 'number' && Number.isNaN(val) ? undefined : val),
+        schema ??
+            z.number({
+                error: getRequiredNumberError,
+            }),
+    );
+
+const optionalNumber = (schema?: z.ZodNumber) =>
+    z.preprocess(
+        (val) => (typeof val === 'number' && Number.isNaN(val) ? undefined : val),
+        (
+            schema ??
+            z.number({
+                error: NUMBER_MESSAGE,
+            })
+        ).optional(),
+    );
+
+const topicNameSchema = z
+    .string({error: REQUIRED_MESSAGE})
+    .min(1, REQUIRED_MESSAGE)
+    .superRefine((value, ctx) => {
+        if (!isValidEntityPath(value)) {
+            addIssue(ctx, [], i18n('error_name-regex'));
+        }
+    });
+
+function validateRequiredNumber(
+    ctx: z.RefinementCtx,
+    path: Array<string | number>,
+    value: number | undefined,
+) {
+    if (value === undefined) {
+        addIssue(ctx, path, i18n('error_required'));
+        return false;
+    }
+
+    return true;
+}
+
+export function getTopicFormValidationSchema(minPartitions: number) {
+    return z
+        .object({
+            path: z.string().optional(),
+            name: topicNameSchema,
+            shards: requiredNumber(
+                z
+                    .number({
+                        error: getRequiredNumberError,
+                    })
+                    .min(1, MIN_ONE_MESSAGE),
+            ),
+            writeQuotaBytes: requiredNumber(),
+            autoPartitioning: z.object({
+                enabled: z.boolean(),
+                mode: z.string({error: REQUIRED_MESSAGE}).min(1, REQUIRED_MESSAGE),
+                minPartitions: optionalNumber(
+                    z.number({error: NUMBER_MESSAGE}).min(1, MIN_ONE_MESSAGE),
+                ),
+                maxPartitions: optionalNumber(
+                    z.number({error: NUMBER_MESSAGE}).min(1, MIN_ONE_MESSAGE),
+                ),
+                stabilizationWindow: optionalNumber(),
+                upUtilization: optionalNumber(
+                    z.number({error: NUMBER_MESSAGE}).max(100, MAX_HUNDRED_MESSAGE),
+                ),
+            }),
+        })
+        .superRefine((data, ctx) => {
+            if (data.shards < minPartitions) {
+                addIssue(ctx, ['shards'], i18n('error_min-number', {count: minPartitions}));
+            }
+
+            const {autoPartitioning} = data;
+
+            if (!autoPartitioning.enabled) {
+                return;
+            }
+
+            const minPath = ['autoPartitioning', 'minPartitions'];
+            const maxPath = ['autoPartitioning', 'maxPartitions'];
+            const stabilizationPath = ['autoPartitioning', 'stabilizationWindow'];
+            const upUtilizationPath = ['autoPartitioning', 'upUtilization'];
+
+            if (
+                validateRequiredNumber(ctx, minPath, autoPartitioning.minPartitions) &&
+                autoPartitioning.minPartitions !== undefined &&
+                autoPartitioning.minPartitions < minPartitions
+            ) {
+                addIssue(ctx, minPath, i18n('error_min-number', {count: minPartitions}));
+            }
+
+            if (validateRequiredNumber(ctx, maxPath, autoPartitioning.maxPartitions)) {
+                const minValue = autoPartitioning.minPartitions;
+                if (
+                    minValue !== undefined &&
+                    autoPartitioning.maxPartitions !== undefined &&
+                    autoPartitioning.maxPartitions < minValue
+                ) {
+                    addIssue(ctx, maxPath, i18n('error_min-number', {count: minValue}));
+                }
+            }
+
+            validateRequiredNumber(ctx, stabilizationPath, autoPartitioning.stabilizationWindow);
+
+            validateRequiredNumber(ctx, upUtilizationPath, autoPartitioning.upUtilization);
+        }) as z.ZodType<TopicFormValues, TopicFormValues>;
+}

package/src/containers/Tenant/constants.tsx

@@ -0,0 +1,26 @@
+import {Flex, Text} from '@gravity-ui/uikit';
+
+import {SelfCheckResult} from '../../types/api/healthcheck';
+
+import i18n from './i18n';
+
+export const ROW_COUNT_NOTE = {
+    children: (
+        <Flex width="528px" direction="column" gap={2}>
+            {i18n('context_row-count-accuracy')
+                .split('\n')
+                .map((paragraph) => (
+                    <Text key={paragraph}>{paragraph}</Text>
+                ))}
+        </Flex>
+    ),
+    popoverProps: {placement: 'right' as const},
+};
+
+export const HEALTHCHECK_RESULT_TO_TEXT: Record<SelfCheckResult, string> = {
+    [SelfCheckResult.UNSPECIFIED]: i18n('context_healthcheck-status-unknown'),
+    [SelfCheckResult.GOOD]: i18n('context_healthcheck-status-ok'),
+    [SelfCheckResult.DEGRADED]: i18n('context_healthcheck-status-degraded'),
+    [SelfCheckResult.MAINTENANCE_REQUIRED]: i18n('context_healthcheck-status-maintenance'),
+    [SelfCheckResult.EMERGENCY]: i18n('context_healthcheck-status-emergency'),
+};

package/src/containers/Tenant/i18n/en.json

@@ -0,0 +1,121 @@
+{
+  "title_database": "Database",
+  "title_query": "Query",
+  "title_diagnostics": "Diagnostics",
+  "title_sql-editor": "SQL Editor",
+  "title_navigation": "Navigation",
+  "action_show-preview": "Show preview",
+  "field_source-type": "Source Type",
+  "field_data-source": "Data Source",
+  "action_copy-schema-path": "Copy schema path",
+  "field_type": "Type",
+  "field_subtype": "SubType",
+  "field_id": "ID",
+  "field_version": "Version",
+  "field_created": "Created",
+  "field_data-size": "Data size",
+  "field_row-count": "Row count",
+  "field_partitions-count": "Partitions count",
+  "title_partitioning": "Partitioning",
+  "field_system-view-type": "System view type",
+  "field_paths": "Paths",
+  "field_shards": "Shards",
+  "field_state": "State",
+  "field_mode": "Mode",
+  "field_format": "Format",
+  "field_retention": "Retention",
+  "title_query-text": "Query text",
+  "value_read-only": "ReadOnly",
+  "alert_copy-path-success": "The path is copied to the clipboard",
+  "alert_copy-path-error": "Couldn’t copy the path",
+  "action_copy-path": "Copy path",
+  "action_connect-to-db": "Connect to DB",
+  "action_drop-index": "Drop index",
+  "action_open-preview": "Open preview",
+  "action_open-monitoring": "Monitoring",
+  "action_create-entity": "Create...",
+  "context_create-entity-through-form": "through the form",
+  "action_create-table": "Create table...",
+  "action_create-external-table": "Create external table...",
+  "action_create-topic": "Create topic...",
+  "action_create-column-table": "Create column table...",
+  "action_create-async-replication": "Create async replication...",
+  "action_create-transfer": "Create transfer...",
+  "action_create-view": "Create view...",
+  "action_create-streaming-query": "Create streaming query...",
+  "action_drop-table": "Drop table...",
+  "action_drop-topic": "Drop topic...",
+  "action_drop-view": "Drop view...",
+  "action_edit-table": "Edit table",
+  "action_alter-table": "Alter table...",
+  "action_manage-columns": "Manage columns...",
+  "action_manage-auto-partitioning": "Manage auto partitioning...",
+  "action_add-read-only-replicas": "Add read-only replicas...",
+  "action_enable-ttl": "Enable TTL...",
+  "action_disable-ttl": "Disable TTL...",
+  "action_add-index": "Add index...",
+  "action_add-vector-index": "Add vector index...",
+  "action_add-fulltext-index": "Add fulltext index...",
+  "action_add-min-max-index": "Add min_max index...",
+  "action_create-changefeed": "Create changefeed...",
+  "action_compaction": "Compaction",
+  "action_show-create-sql": "Show Create SQL...",
+  "action_alter-topic": "Alter topic...",
+  "action_edit-topic": "Edit topic",
+  "action_select-query": "Select query...",
+  "action_upsert-query": "Upsert query...",
+  "action_alter-async-replication": "Alter async replicaton...",
+  "action_alter-transfer": "Alter transfer...",
+  "action_drop-async-replication": "Drop async replicaton...",
+  "action_drop-transfer": "Drop transfer...",
+  "action_alter-secret": "Alter secret...",
+  "action_drop-secret": "Drop secret...",
+  "action_drop-streaming-query": "Drop query...",
+  "action_alter-streaming-query-settings": "Alter query settings...",
+  "action_alter-streaming-query-text": "Alter query text...",
+  "action_create-directory": "Create directory",
+  "field_directory-name": "Name",
+  "alert_invalid-path": "Invalid path",
+  "alert_whitespace-not-allowed": "Whitespace is not allowed",
+  "alert_empty-path": "Path is empty",
+  "title_create-directory": "Create directory",
+  "field_parent-directory": "Inside",
+  "action_cancel": "Cancel",
+  "action_create": "Create",
+  "title_healthcheck-dashboard": "Healthcheck Dashboard",
+
+  "context_row-count-accuracy": "RowCount is an approximate number of rows from YDB partition statistics, not an exact SELECT COUNT(*) result.\nBecause YDB stores table data in LSM levels and updates these stats asynchronously, the estimate can temporarily include rows that will be superseded or removed by background merge/compaction and can lag behind recent writes or deletes. It is useful for observing table size trends, but not for exact row counting.\nUse SELECT COUNT(*) when an exact, transactionally consistent count is required.",
+
+  "context_healthcheck-status-unknown": "Status is unknown",
+  "context_healthcheck-status-ok": "Everything is working fine",
+  "context_healthcheck-status-degraded": "Some issues, but still working",
+  "context_healthcheck-status-maintenance": "Working, but needs urgent attention to avoid failure",
+  "context_healthcheck-status-emergency": "Major outage or severe performance issue. Immediate investigation and action are required",
+  "action_download-healthcheck": "Download healthcheck data",
+
+  "title_grant-access": "Grant access",
+  "context_granular-rights-groups": "Please note that granular rights can be combined into groups",
+
+  "value_database": "Database",
+  "value_directory": "Directory",
+  "value_table": "Table",
+  "value_system-view": "System view",
+  "value_secondary-index": "Secondary Index",
+  "value_vector-index": "Vector Index",
+  "value_fulltext-index": "Fulltext Index",
+  "value_tablestore": "Tablestore",
+  "value_column-oriented-table": "Column-oriented table",
+  "value_changefeed": "Changefeed",
+  "value_topic": "Topic",
+  "value_external-data-source": "External Data Source",
+  "value_external-table": "External Table",
+  "value_view": "View",
+  "value_async-replication": "Async Replication",
+  "value_transfer": "Transfer",
+  "value_resource-pool": "Resource Pool",
+  "value_secret": "Secret",
+  "value_secondary-index-table": "Secondary Index Table",
+  "value_vector-index-table": "Vector Index Table",
+  "value_fulltext-index-table": "Fulltext Index Table",
+  "value_streaming-query": "Streaming Query"
+}

package/src/containers/Tenant/i18n/index.ts

@@ -0,0 +1,7 @@
+import {registerKeysets} from '../../../utils/i18n';
+
+import en from './en.json';
+
+const COMPONENT = 'ydb-tenant';
+
+export default registerKeysets(COMPONENT, {en});

package/src/containers/Tenant/useTenantQueryParams.ts

@@ -0,0 +1,86 @@
+import React from 'react';
+
+import {BooleanParam, StringParam, useQueryParams} from 'use-query-params';
+
+export function useTenantQueryParams() {
+    const [
+        {showHealthcheck, database, schema, view, issuesFilter, showGrantAccess, aclSubject, name},
+        setQueryParams,
+    ] = useQueryParams({
+        name: StringParam,
+        showHealthcheck: BooleanParam,
+        database: StringParam,
+        schema: StringParam,
+        view: StringParam,
+        issuesFilter: StringParam,
+        showGrantAccess: BooleanParam,
+        aclSubject: StringParam,
+    });
+    const handleShowHealthcheckChange = React.useCallback(
+        (value?: boolean) => {
+            setQueryParams({showHealthcheck: value || undefined}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+    const handleAclSubjectChange = React.useCallback(
+        (value?: string) => {
+            setQueryParams({aclSubject: value}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+    const handleShowGrantAccessChange = React.useCallback(
+        (value?: boolean) => {
+            setQueryParams({showGrantAccess: value || undefined}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+
+    const handleDatabaseChange = React.useCallback(
+        (value?: string) => {
+            setQueryParams({database: value}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+
+    const handleSchemaChange = React.useCallback(
+        (value?: string) => {
+            setQueryParams({schema: value}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+    const handleIssuesFilterChange = React.useCallback(
+        (value?: string) => {
+            setQueryParams({issuesFilter: value}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+    const handleHealthcheckViewChange = React.useCallback(
+        (value?: string) => {
+            setQueryParams({view: value}, 'replaceIn');
+        },
+        [setQueryParams],
+    );
+
+    React.useEffect(() => {
+        if (name && !database) {
+            setQueryParams({database: name, name: undefined}, 'replaceIn');
+        }
+    }, [database, name, setQueryParams]);
+
+    return {
+        showHealthcheck,
+        handleShowHealthcheckChange,
+        database: database || name,
+        handleDatabaseChange,
+        showGrantAccess,
+        handleShowGrantAccessChange,
+        schema,
+        handleSchemaChange,
+        view,
+        handleHealthcheckViewChange,
+        issuesFilter,
+        handleIssuesFilterChange,
+        aclSubject,
+        handleAclSubjectChange,
+    };
+}

package/src/containers/Tenant/utils/ToggleButton.scss

@@ -0,0 +1,24 @@
+.kv-pane-visibility-button {
+    &_hidden {
+        display: none;
+    }
+
+    &_bottom {
+        transform: rotate(180deg);
+    }
+
+    &_bottom.rotate {
+        transform: rotate(0);
+    }
+    &_left {
+        transform: rotate(-90deg);
+    }
+
+    &_left.rotate {
+        transform: rotate(90deg);
+    }
+
+    &_top.rotate {
+        transform: rotate(180deg);
+    }
+}

package/src/containers/Tenant/utils/constants.ts

@@ -0,0 +1,10 @@
+import type {Settings} from '@gravity-ui/react-data-table';
+
+import {DEFAULT_TABLE_SETTINGS} from '../../../utils/constants';
+
+export const MAX_QUERY_HEIGHT = 3;
+
+export const QUERY_TABLE_SETTINGS: Settings = {
+    ...DEFAULT_TABLE_SETTINGS,
+    dynamicRenderType: 'uniform',
+};