ydb-embedded-ui 6.4.0 → 6.6.0

package/dist/src/containers/Tenant/Schema/SchemaViewer/columns.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DataTable from '@gravity-ui/react-data-table';
+import { Icon } from '@gravity-ui/uikit';
+import i18n from './i18n';
+import { b } from './shared';
+import keyIcon from '../../../../assets/icons/key.svg';
+export const SCHEMA_COLUMNS_WIDTH_LS_KEY = 'schemaTableColumnsWidth';
+export const SCHEMA_TABLE_COLUMS_IDS = {
+    id: 'id',
+    name: 'name',
+    isKeyColumn: 'isKeyColumn',
+    type: 'type',
+    notNull: 'notNull',
+    familyName: 'familyName',
+    prefferedPoolKind: 'prefferedPoolKind',
+    columnCodec: 'columnCodec',
+};
+const idColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.id,
+    get header() {
+        return i18n('column-title.id');
+    },
+    width: 60,
+    render: ({ row }) => row.id,
+};
+const nameColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.name,
+    get header() {
+        return i18n('column-title.name');
+    },
+    width: 100,
+    render: ({ row }) => row.name,
+};
+const keyColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.isKeyColumn,
+    get header() {
+        return i18n('column-title.key');
+    },
+    width: 70,
+    resizeMinWidth: 70,
+    // Table should start with key columns on sort click
+    defaultOrder: DataTable.ASCENDING,
+    sortAccessor: (row) => row.keyAccessor,
+    render: ({ row }) => {
+        return row.isKeyColumn ? (_jsx("div", { className: b('key-icon'), children: _jsx(Icon, { data: keyIcon, width: 12, height: 7 }) })) : null;
+    },
+};
+const typeColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.type,
+    get header() {
+        return i18n('column-title.type');
+    },
+    width: 100,
+    render: ({ row }) => row.type,
+};
+const notNullColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.notNull,
+    get header() {
+        return i18n('column-title.notNull');
+    },
+    width: 100,
+    // Table should start with notNull columns on sort click
+    defaultOrder: DataTable.DESCENDING,
+    render: ({ row }) => {
+        if (row.notNull) {
+            return '\u2713';
+        }
+        return undefined;
+    },
+};
+const familyColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.familyName,
+    get header() {
+        return i18n('column-title.family');
+    },
+    width: 100,
+    render: ({ row }) => row.familyName,
+};
+const mediaColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.prefferedPoolKind,
+    get header() {
+        return i18n('column-title.media');
+    },
+    width: 100,
+    render: ({ row }) => row.prefferedPoolKind,
+};
+const compressionColumn = {
+    name: SCHEMA_TABLE_COLUMS_IDS.columnCodec,
+    get header() {
+        return i18n('column-title.compression');
+    },
+    width: 100,
+    render: ({ row }) => row.columnCodec,
+};
+export function getViewColumns() {
+    return [nameColumn, typeColumn];
+}
+export function getExternalTableColumns() {
+    return [idColumn, nameColumn, typeColumn, notNullColumn];
+}
+export function getColumnTableColumns() {
+    return [idColumn, keyColumn, nameColumn, typeColumn, notNullColumn];
+}
+export function getRowTableColumns(extended) {
+    const rowTableColumns = [idColumn, keyColumn, nameColumn, typeColumn, notNullColumn];
+    if (extended) {
+        return rowTableColumns.concat(familyColumn, mediaColumn, compressionColumn);
+    }
+    return rowTableColumns;
+}

package/dist/src/containers/Tenant/Schema/SchemaViewer/i18n/en.json

@@ -0,0 +1,10 @@
+{
+    "column-title.id": "Id",
+    "column-title.name": "Name",
+    "column-title.key": "Key",
+    "column-title.type": "Type",
+    "column-title.notNull": "NotNull",
+    "column-title.family": "Family",
+    "column-title.media": "Media",
+    "column-title.compression": "Compression"
+}

package/dist/src/containers/Tenant/Schema/SchemaViewer/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: "column-title.id" | "column-title.name" | "column-title.key" | "column-title.type" | "column-title.notNull" | "column-title.family" | "column-title.media" | "column-title.compression", params?: import("@gravity-ui/i18n").Params | undefined) => string;
+export default _default;

package/dist/src/containers/Tenant/Schema/SchemaViewer/i18n/index.js

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

package/dist/src/containers/Tenant/Schema/SchemaViewer/prepareData.d.ts

@@ -0,0 +1,6 @@
+import type { ColumnType } from '../../../../types/api/query';
+import type { EPathType, TEvDescribeSchemeResult, TFamilyDescription, TTableDescription } from '../../../../types/api/schema';
+import type { SchemaData } from './types';
+export declare function prepareFamilies(data?: TTableDescription): Record<number, TFamilyDescription>;
+export declare function prepareSchemaData(type?: EPathType, schema?: TEvDescribeSchemeResult): SchemaData[];
+export declare function prepareViewSchema(columns?: ColumnType[]): SchemaData[];

package/dist/src/containers/Tenant/Schema/SchemaViewer/prepareData.js

@@ -0,0 +1,114 @@
+import { EColumnCodec } from '../../../../types/api/schema';
+import { isColumnEntityType, isExternalTableType, isRowTableType } from '../../utils/schema';
+function getKeyColumnsSortAccessorMap(ids = []) {
+    return ids.reduce((result, keyColumnId, index) => {
+        // Put columns with negative values, so they will be the first with ascending sort
+        // Minus keyColumnIds.length for the first key, -1 for the last
+        return Object.assign(Object.assign({}, result), { [keyColumnId]: index - ids.length });
+    }, {});
+}
+function formatColumnCodec(codec) {
+    if (!codec) {
+        return undefined;
+    }
+    if (codec === EColumnCodec.ColumnCodecPlain) {
+        return 'None';
+    }
+    return codec.replace('ColumnCodec', '').toLocaleLowerCase();
+}
+export function prepareFamilies(data) {
+    var _a, _b, _c;
+    return ((_c = (_b = (_a = data === null || data === void 0 ? void 0 : data.PartitionConfig) === null || _a === void 0 ? void 0 : _a.ColumnFamilies) === null || _b === void 0 ? void 0 : _b.reduce((acc, family) => {
+        if (family.Id) {
+            return Object.assign(Object.assign({}, acc), { [family.Id]: family });
+        }
+        return acc;
+    }, {})) !== null && _c !== void 0 ? _c : {});
+}
+function prepareRowTableSchema(data = {}) {
+    const families = prepareFamilies(data);
+    const { Columns, KeyColumnIds } = data;
+    const keyAccessorsMap = getKeyColumnsSortAccessorMap(KeyColumnIds);
+    const preparedColumns = Columns === null || Columns === void 0 ? void 0 : Columns.map((column) => {
+        var _a, _b;
+        const { Id, Name, NotNull, Type, Family } = column;
+        const isKeyColumn = Boolean(KeyColumnIds === null || KeyColumnIds === void 0 ? void 0 : KeyColumnIds.find((keyColumnId) => keyColumnId === Id));
+        // Values in keyAccessorsMap are always negative, so it will be 1 for not key columns
+        const keyAccessor = Id && keyAccessorsMap[Id] ? keyAccessorsMap[Id] : 1;
+        const familyName = Family ? families[Family].Name : undefined;
+        const prefferedPoolKind = Family
+            ? (_b = (_a = families[Family].StorageConfig) === null || _a === void 0 ? void 0 : _a.Data) === null || _b === void 0 ? void 0 : _b.PreferredPoolKind
+            : undefined;
+        const columnCodec = Family ? formatColumnCodec(families[Family].ColumnCodec) : undefined;
+        return {
+            id: Id,
+            name: Name,
+            isKeyColumn,
+            keyAccessor,
+            type: Type,
+            notNull: NotNull,
+            familyName,
+            prefferedPoolKind,
+            columnCodec,
+        };
+    });
+    return preparedColumns || [];
+}
+function prepareExternalTableSchema(data = {}) {
+    const { Columns } = data;
+    const preparedColumns = Columns === null || Columns === void 0 ? void 0 : Columns.map((column) => {
+        const { Id, Name, Type, NotNull } = column;
+        return {
+            id: Id,
+            name: Name,
+            type: Type,
+            notNull: NotNull,
+        };
+    });
+    return preparedColumns || [];
+}
+function prepareColumnTableSchema(data = {}) {
+    const { Schema = {} } = data;
+    const { Columns, KeyColumnNames } = Schema;
+    const keyAccessorsMap = getKeyColumnsSortAccessorMap(KeyColumnNames);
+    const preparedColumns = Columns === null || Columns === void 0 ? void 0 : Columns.map((column) => {
+        const { Id, Name, Type, NotNull } = column;
+        const isKeyColumn = Boolean(KeyColumnNames === null || KeyColumnNames === void 0 ? void 0 : KeyColumnNames.find((keyColumnName) => keyColumnName === Name));
+        // Values in keyAccessorsMap are always negative, so it will be 1 for not key columns
+        const keyAccessor = Name && keyAccessorsMap[Name] ? keyAccessorsMap[Name] : 1;
+        return {
+            id: Id,
+            name: Name,
+            isKeyColumn,
+            keyAccessor,
+            type: Type,
+            notNull: NotNull,
+        };
+    });
+    return preparedColumns || [];
+}
+export function prepareSchemaData(type, schema) {
+    const { Table, ColumnTableDescription, ExternalTableDescription } = (schema === null || schema === void 0 ? void 0 : schema.PathDescription) || {};
+    if (isRowTableType(type)) {
+        return prepareRowTableSchema(Table);
+    }
+    else if (isColumnEntityType(type)) {
+        return prepareColumnTableSchema(ColumnTableDescription);
+    }
+    else if (isExternalTableType(type)) {
+        return prepareExternalTableSchema(ExternalTableDescription);
+    }
+    return [];
+}
+export function prepareViewSchema(columns) {
+    const preparedColumns = columns === null || columns === void 0 ? void 0 : columns.map((column) => {
+        var _a;
+        // View may have columns like Uint64? or Utf8?
+        const type = ((_a = column.type) === null || _a === void 0 ? void 0 : _a.endsWith('?')) ? column.type.slice(0, -1) : column.type;
+        return {
+            type,
+            name: column.name,
+        };
+    });
+    return preparedColumns || [];
+}

package/dist/src/containers/Tenant/Schema/SchemaViewer/shared.d.ts

@@ -0,0 +1 @@
+export declare const b: import("@bem-react/classname").ClassNameFormatter;

package/dist/src/containers/Tenant/Schema/SchemaViewer/shared.js

@@ -0,0 +1,2 @@
+import { cn } from '../../../../utils/cn';
+export const b = cn('schema-viewer');

package/dist/src/containers/Tenant/Schema/SchemaViewer/types.d.ts

@@ -0,0 +1,16 @@
+import type { Column } from '@gravity-ui/react-data-table';
+export interface SchemaData {
+    id?: number;
+    name?: string;
+    isKeyColumn?: boolean;
+    /** value to sort keys, needed to ensure that key columns will be the first */
+    keyAccessor?: number;
+    type?: string;
+    notNull?: boolean;
+    familyName?: string;
+    prefferedPoolKind?: string;
+    columnCodec?: string;
+}
+export interface SchemaColumn extends Column<SchemaData> {
+    name: keyof SchemaData;
+}

package/dist/src/containers/Tenant/Tenant.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import qs from 'qs';
+import { Helmet } from 'react-helmet-async';
+import { useLocation } from 'react-router';
+import { AccessDenied } from '../../components/Errors/403';
+import SplitPane from '../../components/SplitPane';
+import { setHeaderBreadcrumbs } from '../../store/reducers/header/header';
+import { getSchema } from '../../store/reducers/schema/schema';
+import { cn } from '../../utils/cn';
+import { DEFAULT_IS_TENANT_SUMMARY_COLLAPSED, DEFAULT_SIZE_TENANT_KEY } from '../../utils/constants';
+import { useTypedDispatch, useTypedSelector } from '../../utils/hooks';
+import ObjectGeneral from './ObjectGeneral/ObjectGeneral';
+import { ObjectSummary } from './ObjectSummary/ObjectSummary';
+import i18n from './i18n';
+import { PaneVisibilityActionTypes, paneVisibilityToggleReducerCreator, } from './utils/paneVisibilityToggleHelpers';
+import './Tenant.scss';
+const b = cn('tenant-page');
+const getTenantSummaryState = () => {
+    const collapsed = Boolean(localStorage.getItem(DEFAULT_IS_TENANT_SUMMARY_COLLAPSED));
+    return {
+        triggerExpand: false,
+        triggerCollapse: false,
+        collapsed,
+    };
+};
+function Tenant(props) {
+    var _a;
+    const [summaryVisibilityState, dispatchSummaryVisibilityAction] = React.useReducer(paneVisibilityToggleReducerCreator(DEFAULT_IS_TENANT_SUMMARY_COLLAPSED), undefined, getTenantSummaryState);
+    const previousTenant = React.useRef();
+    const { currentSchemaPath, currentSchema: currentItem = {} } = useTypedSelector((state) => state.schema);
+    const { PathType: preloadedPathType, PathSubType: preloadedPathSubType } = useTypedSelector((state) => {
+        var _a, _b;
+        return currentSchemaPath
+            ? (_b = (_a = state.schema.data[currentSchemaPath]) === null || _a === void 0 ? void 0 : _a.PathDescription) === null || _b === void 0 ? void 0 : _b.Self
+            : undefined;
+    }) || {};
+    const { PathType: currentPathType, PathSubType: currentPathSubType } = ((_a = currentItem.PathDescription) === null || _a === void 0 ? void 0 : _a.Self) || {};
+    const { error: { status: schemaStatus = 200 } = {} } = useTypedSelector((state) => state.schema);
+    const dispatch = useTypedDispatch();
+    const location = useLocation();
+    const queryParams = qs.parse(location.search, {
+        ignoreQueryPrefix: true,
+    });
+    const { name } = queryParams;
+    const tenantName = name;
+    React.useEffect(() => {
+        if (tenantName && typeof tenantName === 'string' && previousTenant.current !== tenantName) {
+            const register = async () => {
+                const { registerYQLCompletionItemProvider } = await import('../../utils/monaco/yql/yql.completionItemProvider');
+                registerYQLCompletionItemProvider(tenantName);
+            };
+            register().catch(console.error);
+            previousTenant.current = tenantName;
+        }
+    }, [tenantName]);
+    React.useEffect(() => {
+        dispatch(getSchema({ path: tenantName }));
+    }, [tenantName, dispatch]);
+    React.useEffect(() => {
+        //TODO: should be refactored when move to @reduxjs/toolkit/query
+        if (currentSchemaPath && currentSchemaPath !== tenantName) {
+            dispatch(getSchema({ path: currentSchemaPath }));
+        }
+    }, [currentSchemaPath, dispatch, tenantName]);
+    React.useEffect(() => {
+        if (tenantName) {
+            dispatch(setHeaderBreadcrumbs('tenant', { tenantName }));
+        }
+    }, [tenantName, dispatch]);
+    const onCollapseSummaryHandler = () => {
+        dispatchSummaryVisibilityAction(PaneVisibilityActionTypes.triggerCollapse);
+    };
+    const onExpandSummaryHandler = () => {
+        dispatchSummaryVisibilityAction(PaneVisibilityActionTypes.triggerExpand);
+    };
+    const onSplitStartDragAdditional = () => {
+        dispatchSummaryVisibilityAction(PaneVisibilityActionTypes.clear);
+    };
+    const showBlockingError = schemaStatus === 403;
+    const title = currentSchemaPath || tenantName || i18n('page.title');
+    return (_jsxs("div", { className: b(), children: [_jsx(Helmet, { defaultTitle: `${title} — YDB Monitoring`, titleTemplate: `%s — ${title} — YDB Monitoring` }), showBlockingError ? (_jsx(AccessDenied, {})) : (_jsxs(SplitPane, { defaultSizePaneKey: DEFAULT_SIZE_TENANT_KEY, defaultSizes: [25, 75], triggerCollapse: summaryVisibilityState.triggerCollapse, triggerExpand: summaryVisibilityState.triggerExpand, minSize: [36, 200], onSplitStartDragAdditional: onSplitStartDragAdditional, children: [_jsx(ObjectSummary, { type: preloadedPathType || currentPathType, subType: preloadedPathSubType || currentPathSubType, tenantName: tenantName, onCollapseSummary: onCollapseSummaryHandler, onExpandSummary: onExpandSummaryHandler, isCollapsed: summaryVisibilityState.collapsed }), _jsx(ObjectGeneral, { type: preloadedPathType || currentPathType, additionalTenantProps: props.additionalTenantProps, additionalNodesProps: props.additionalNodesProps, tenantName: tenantName })] }))] }));
+}
+export default Tenant;

package/dist/src/containers/Tenant/utils/schema.js

@@ -0,0 +1,189 @@
+import { EPathSubType, EPathType } from '../../../types/api/schema';
+import { ETenantType } from '../../../types/api/tenant';
+// this file contains verbose mappings that are typed in a way that ensures
+// correctness when a new node type or a new path type is added
+// TS will error if a new entity is added but not mapped here
+const pathSubTypeToNodeType = {
+    [EPathSubType.EPathSubTypeSyncIndexImplTable]: 'index_table',
+    [EPathSubType.EPathSubTypeAsyncIndexImplTable]: 'index_table',
+    [EPathSubType.EPathSubTypeStreamImpl]: undefined,
+    [EPathSubType.EPathSubTypeEmpty]: undefined,
+};
+const pathTypeToNodeType = {
+    [EPathType.EPathTypeInvalid]: undefined,
+    [EPathType.EPathTypeSubDomain]: 'database',
+    [EPathType.EPathTypeExtSubDomain]: 'database',
+    [EPathType.EPathTypeDir]: 'directory',
+    [EPathType.EPathTypeColumnStore]: 'directory',
+    [EPathType.EPathTypeTable]: 'table',
+    [EPathType.EPathTypeTableIndex]: 'index',
+    [EPathType.EPathTypeColumnTable]: 'column_table',
+    [EPathType.EPathTypeCdcStream]: 'stream',
+    [EPathType.EPathTypePersQueueGroup]: 'topic',
+    [EPathType.EPathTypeExternalDataSource]: 'external_data_source',
+    [EPathType.EPathTypeExternalTable]: 'external_table',
+    [EPathType.EPathTypeView]: 'view',
+    [EPathType.EPathTypeReplication]: 'async_replication',
+};
+export const mapPathTypeToNavigationTreeType = (type = EPathType.EPathTypeDir, subType, defaultType = 'directory') => (subType && pathSubTypeToNodeType[subType]) || pathTypeToNodeType[type] || defaultType;
+// ====================
+const pathSubTypeToEntityName = {
+    [EPathSubType.EPathSubTypeSyncIndexImplTable]: 'Secondary Index Table',
+    [EPathSubType.EPathSubTypeAsyncIndexImplTable]: 'Secondary Index Table',
+    [EPathSubType.EPathSubTypeStreamImpl]: undefined,
+    [EPathSubType.EPathSubTypeEmpty]: undefined,
+};
+const pathTypeToEntityName = {
+    [EPathType.EPathTypeInvalid]: undefined,
+    [EPathType.EPathTypeSubDomain]: 'Database',
+    [EPathType.EPathTypeExtSubDomain]: 'Database',
+    [EPathType.EPathTypeDir]: 'Directory',
+    [EPathType.EPathTypeTable]: 'Table',
+    [EPathType.EPathTypeTableIndex]: 'Secondary Index',
+    [EPathType.EPathTypeColumnStore]: 'Tablestore',
+    [EPathType.EPathTypeColumnTable]: 'Columntable',
+    [EPathType.EPathTypeCdcStream]: 'Changefeed',
+    [EPathType.EPathTypePersQueueGroup]: 'Topic',
+    [EPathType.EPathTypeExternalDataSource]: 'External Data Source',
+    [EPathType.EPathTypeExternalTable]: 'External Table',
+    [EPathType.EPathTypeView]: 'View',
+    [EPathType.EPathTypeReplication]: 'Async Replication',
+};
+export const mapPathTypeToEntityName = (type, subType) => (subType && pathSubTypeToEntityName[subType]) || (type && pathTypeToEntityName[type]);
+// ====================
+const databaseTypeToDBName = {
+    [ETenantType.UnknownTenantType]: 'Database',
+    [ETenantType.Domain]: 'Cluster Root',
+    [ETenantType.Dedicated]: 'Dedicated Database',
+    [ETenantType.Shared]: 'Shared Database',
+    [ETenantType.Serverless]: 'Serverless Database',
+};
+export const mapDatabaseTypeToDBName = (type) => type && databaseTypeToDBName[type];
+// ====================
+const pathTypeToIsTable = {
+    [EPathType.EPathTypeTable]: true,
+    [EPathType.EPathTypeColumnTable]: true,
+    [EPathType.EPathTypeExternalTable]: true,
+    [EPathType.EPathTypeView]: true,
+    [EPathType.EPathTypeInvalid]: false,
+    [EPathType.EPathTypeDir]: false,
+    [EPathType.EPathTypeSubDomain]: false,
+    [EPathType.EPathTypeTableIndex]: false,
+    [EPathType.EPathTypeExtSubDomain]: false,
+    [EPathType.EPathTypeColumnStore]: false,
+    [EPathType.EPathTypeCdcStream]: false,
+    [EPathType.EPathTypePersQueueGroup]: false,
+    [EPathType.EPathTypeExternalDataSource]: false,
+    [EPathType.EPathTypeReplication]: false,
+};
+export const isTableType = (pathType) => { var _a; return (_a = (pathType && pathTypeToIsTable[pathType])) !== null && _a !== void 0 ? _a : false; };
+// ====================
+const pathSubTypeToIsIndexImpl = {
+    [EPathSubType.EPathSubTypeSyncIndexImplTable]: true,
+    [EPathSubType.EPathSubTypeAsyncIndexImplTable]: true,
+    [EPathSubType.EPathSubTypeStreamImpl]: false,
+    [EPathSubType.EPathSubTypeEmpty]: false,
+};
+export const isIndexTableType = (subType) => { var _a; return (_a = (subType && pathSubTypeToIsIndexImpl[subType])) !== null && _a !== void 0 ? _a : false; };
+// ====================
+const pathTypeToIsColumn = {
+    [EPathType.EPathTypeColumnStore]: true,
+    [EPathType.EPathTypeColumnTable]: true,
+    [EPathType.EPathTypeInvalid]: false,
+    [EPathType.EPathTypeDir]: false,
+    [EPathType.EPathTypeTable]: false,
+    [EPathType.EPathTypeSubDomain]: false,
+    [EPathType.EPathTypeTableIndex]: false,
+    [EPathType.EPathTypeExtSubDomain]: false,
+    [EPathType.EPathTypeCdcStream]: false,
+    [EPathType.EPathTypePersQueueGroup]: false,
+    [EPathType.EPathTypeExternalDataSource]: false,
+    [EPathType.EPathTypeExternalTable]: false,
+    [EPathType.EPathTypeView]: false,
+    [EPathType.EPathTypeReplication]: false,
+};
+export const isColumnEntityType = (type) => { var _a; return (_a = (type && pathTypeToIsColumn[type])) !== null && _a !== void 0 ? _a : false; };
+// ====================
+const pathTypeToIsDatabase = {
+    [EPathType.EPathTypeSubDomain]: true,
+    [EPathType.EPathTypeExtSubDomain]: true,
+    [EPathType.EPathTypeInvalid]: false,
+    [EPathType.EPathTypeDir]: false,
+    [EPathType.EPathTypeColumnStore]: false,
+    [EPathType.EPathTypeColumnTable]: false,
+    [EPathType.EPathTypeTable]: false,
+    [EPathType.EPathTypeTableIndex]: false,
+    [EPathType.EPathTypeCdcStream]: false,
+    [EPathType.EPathTypePersQueueGroup]: false,
+    [EPathType.EPathTypeExternalDataSource]: false,
+    [EPathType.EPathTypeExternalTable]: false,
+    [EPathType.EPathTypeView]: false,
+    [EPathType.EPathTypeReplication]: false,
+};
+export const isDatabaseEntityType = (type) => { var _a; return (_a = (type && pathTypeToIsDatabase[type])) !== null && _a !== void 0 ? _a : false; };
+// ====================
+export const isCdcStreamEntityType = (type) => type === EPathType.EPathTypeCdcStream;
+// ====================
+const pathTypeToEntityWithMergedImplementation = {
+    [EPathType.EPathTypeCdcStream]: true,
+    [EPathType.EPathTypePersQueueGroup]: false,
+    [EPathType.EPathTypeInvalid]: false,
+    [EPathType.EPathTypeColumnStore]: false,
+    [EPathType.EPathTypeColumnTable]: false,
+    [EPathType.EPathTypeDir]: false,
+    [EPathType.EPathTypeTable]: false,
+    [EPathType.EPathTypeSubDomain]: false,
+    [EPathType.EPathTypeTableIndex]: false,
+    [EPathType.EPathTypeExtSubDomain]: false,
+    [EPathType.EPathTypeExternalDataSource]: false,
+    [EPathType.EPathTypeExternalTable]: false,
+    [EPathType.EPathTypeView]: false,
+    [EPathType.EPathTypeReplication]: false,
+};
+export const isEntityWithMergedImplementation = (type) => { var _a; return (_a = (type && pathTypeToEntityWithMergedImplementation[type])) !== null && _a !== void 0 ? _a : false; };
+// ====================
+const pathSubTypeToChildless = {
+    [EPathSubType.EPathSubTypeSyncIndexImplTable]: true,
+    [EPathSubType.EPathSubTypeAsyncIndexImplTable]: true,
+    [EPathSubType.EPathSubTypeStreamImpl]: false,
+    [EPathSubType.EPathSubTypeEmpty]: false,
+};
+const pathTypeToChildless = {
+    [EPathType.EPathTypeCdcStream]: true,
+    [EPathType.EPathTypePersQueueGroup]: true,
+    [EPathType.EPathTypeExternalDataSource]: true,
+    [EPathType.EPathTypeExternalTable]: true,
+    [EPathType.EPathTypeView]: true,
+    [EPathType.EPathTypeReplication]: true,
+    [EPathType.EPathTypeInvalid]: false,
+    [EPathType.EPathTypeColumnStore]: false,
+    [EPathType.EPathTypeColumnTable]: false,
+    [EPathType.EPathTypeDir]: false,
+    [EPathType.EPathTypeTable]: false,
+    [EPathType.EPathTypeSubDomain]: false,
+    [EPathType.EPathTypeTableIndex]: false,
+    [EPathType.EPathTypeExtSubDomain]: false,
+};
+export const isChildlessPathType = (type, subType) => { var _a; return (_a = ((subType && pathSubTypeToChildless[subType]) || (type && pathTypeToChildless[type]))) !== null && _a !== void 0 ? _a : false; };
+// ====================
+const mapPathTypeToIsWithTopic = {
+    [EPathType.EPathTypeCdcStream]: true,
+    [EPathType.EPathTypePersQueueGroup]: true,
+    [EPathType.EPathTypeInvalid]: false,
+    [EPathType.EPathTypeColumnStore]: false,
+    [EPathType.EPathTypeColumnTable]: false,
+    [EPathType.EPathTypeDir]: false,
+    [EPathType.EPathTypeTable]: false,
+    [EPathType.EPathTypeSubDomain]: false,
+    [EPathType.EPathTypeTableIndex]: false,
+    [EPathType.EPathTypeExtSubDomain]: false,
+    [EPathType.EPathTypeExternalDataSource]: false,
+    [EPathType.EPathTypeExternalTable]: false,
+    [EPathType.EPathTypeView]: false,
+    [EPathType.EPathTypeReplication]: false,
+};
+export const isPathTypeWithTopic = (type) => { var _a; return (_a = (type && mapPathTypeToIsWithTopic[type])) !== null && _a !== void 0 ? _a : false; };
+// ====================
+export const isExternalTableType = (type) => type === EPathType.EPathTypeExternalTable;
+export const isRowTableType = (type) => type === EPathType.EPathTypeTable;
+export const isViewType = (type) => type === EPathType.EPathTypeView;

package/dist/src/containers/Tenant/utils/schemaActions.js

@@ -0,0 +1,114 @@
+import copy from 'copy-to-clipboard';
+import { changeUserInput } from '../../../store/reducers/executeQuery';
+import { TENANT_PAGES_IDS, TENANT_QUERY_TABS_ID } from '../../../store/reducers/tenant/constants';
+import { setQueryTab, setTenantPage } from '../../../store/reducers/tenant/tenant';
+import createToast from '../../../utils/createToast';
+import i18n from '../i18n';
+import { alterTableTemplate, alterTopicTemplate, createExternalTableTemplate, createTableTemplate, createTopicTemplate, createViewTemplate, dropExternalTableTemplate, dropTopicTemplate, dropViewTemplate, selectQueryTemplate, upsertQueryTemplate, } from './queryTemplates';
+const bindActions = (path, dispatch, additionalEffects) => {
+    const { setActivePath, setQueryMode } = additionalEffects;
+    const inputQuery = (tmpl, mode) => () => {
+        if (mode) {
+            setQueryMode(mode);
+        }
+        dispatch(changeUserInput({ input: tmpl(path) }));
+        dispatch(setTenantPage(TENANT_PAGES_IDS.query));
+        dispatch(setQueryTab(TENANT_QUERY_TABS_ID.newQuery));
+        setActivePath(path);
+    };
+    return {
+        createTable: inputQuery(createTableTemplate, 'script'),
+        alterTable: inputQuery(alterTableTemplate, 'script'),
+        selectQuery: inputQuery(selectQueryTemplate),
+        upsertQuery: inputQuery(upsertQueryTemplate),
+        createExternalTable: inputQuery(createExternalTableTemplate, 'script'),
+        dropExternalTable: inputQuery(dropExternalTableTemplate, 'script'),
+        selectQueryFromExternalTable: inputQuery(selectQueryTemplate, 'query'),
+        createTopic: inputQuery(createTopicTemplate, 'script'),
+        alterTopic: inputQuery(alterTopicTemplate, 'script'),
+        dropTopic: inputQuery(dropTopicTemplate, 'script'),
+        createView: inputQuery(createViewTemplate, 'script'),
+        dropView: inputQuery(dropViewTemplate, 'script'),
+        copyPath: () => {
+            try {
+                copy(path);
+                createToast({
+                    name: 'Copied',
+                    title: i18n('actions.copied'),
+                    type: 'success',
+                });
+            }
+            catch (_a) {
+                createToast({
+                    name: 'Not copied',
+                    title: i18n('actions.notCopied'),
+                    type: 'error',
+                });
+            }
+        },
+    };
+};
+export const getActions = (dispatch, additionalEffects) => (path, type) => {
+    const actions = bindActions(path, dispatch, additionalEffects);
+    const copyItem = { text: i18n('actions.copyPath'), action: actions.copyPath };
+    const DIR_SET = [
+        [copyItem],
+        [
+            { text: i18n('actions.createTable'), action: actions.createTable },
+            { text: i18n('actions.createTopic'), action: actions.createTopic },
+            { text: i18n('actions.createView'), action: actions.createView },
+        ],
+    ];
+    const TABLE_SET = [
+        [copyItem],
+        [
+            { text: i18n('actions.alterTable'), action: actions.alterTable },
+            { text: i18n('actions.selectQuery'), action: actions.selectQuery },
+            { text: i18n('actions.upsertQuery'), action: actions.upsertQuery },
+        ],
+    ];
+    const TOPIC_SET = [
+        [copyItem],
+        [
+            { text: i18n('actions.alterTopic'), action: actions.alterTopic },
+            { text: i18n('actions.dropTopic'), action: actions.dropTopic },
+        ],
+    ];
+    const EXTERNAL_TABLE_SET = [
+        [copyItem],
+        [
+            {
+                text: i18n('actions.selectQuery'),
+                action: actions.selectQueryFromExternalTable,
+            },
+        ],
+        [{ text: i18n('actions.dropTable'), action: actions.dropExternalTable }],
+    ];
+    const EXTERNAL_DATA_SOURCE_SET = [
+        [copyItem],
+        [{ text: i18n('actions.createExternalTable'), action: actions.createExternalTable }],
+    ];
+    const VIEW_SET = [
+        [copyItem],
+        [{ text: i18n('actions.selectQuery'), action: actions.selectQuery }],
+        [{ text: i18n('actions.dropView'), action: actions.dropView }],
+    ];
+    const JUST_COPY = [copyItem];
+    // verbose mapping to guarantee a correct actions set for new node types
+    // TS will error when a new type is added in the lib but is not mapped here
+    const nodeTypeToActions = {
+        async_replication: JUST_COPY,
+        database: DIR_SET,
+        directory: DIR_SET,
+        table: TABLE_SET,
+        column_table: TABLE_SET,
+        index_table: JUST_COPY,
+        topic: TOPIC_SET,
+        stream: JUST_COPY,
+        index: JUST_COPY,
+        external_table: EXTERNAL_TABLE_SET,
+        external_data_source: EXTERNAL_DATA_SOURCE_SET,
+        view: VIEW_SET,
+    };
+    return nodeTypeToActions[type];
+};