feat(Query): default ACO [#436]

packages/ui/src/shared/constants/settings-types.ts

@@ -70,6 +70,7 @@ interface AccountsSettings {
 }
 
 type ClusterName = string;
+type Stage = string;
 
 interface QueryTrackerSettings {
     'global::queryTracker::queriesListSidebarVisibilityMode': boolean;
@@ -81,7 +82,7 @@ interface ChytSettings {
 }
 
 type QueryTrackerLastSelectedACOsSettings = {
-    [key in `local::${ClusterName}::queryTracker::lastSelectedACOs`]: string[];
+    [key in `qt-stage::${ClusterName}::queryTracker::${Stage}::lastSelectedACOs`]: string[];
 };
 
 interface OtherSettings {

packages/ui/src/shared/yt-types.d.ts

@@ -24,6 +24,7 @@ export interface ClusterUiConfig {
     enable_maintenance_api_proxies?: boolean;
     chyt_controller_base_url?: string;
     livy_controller_base_url?: string;
+    query_tracker_default_aco?: Record<string, string>;
     job_trace_url_template?: {
         title: string;
         url_template: string;

packages/ui/src/ui/pages/query-tracker/QueryResults/hooks/useCurrentQuery.ts

@@ -2,13 +2,14 @@ import {useContext, useEffect, useMemo} from 'react';
 import {useDispatch, useSelector} from 'react-redux';
 import {QueriesPoolingContext} from '../../hooks/QueriesPooling/context';
 import {UPDATE_QUERY} from '../../module/query/actions';
-import {getCurrentQuery} from '../../module/query/selectors';
+import {getCurrentQuery, getDefaultQueryACO} from '../../module/query/selectors';
 import {isQueryProgress} from '../../utils/query';
 import {QueryItem} from '../../module/api';
 import {prepareQueryPlanIds} from '../../module/query/utills';
 
 export function useCurrentQuery() {
     const query = useSelector(getCurrentQuery);
+    const defaultQueryACO = useSelector(getDefaultQueryACO);
     const pollingContext = useContext(QueriesPoolingContext);
 
     const dispatch = useDispatch();
@@ -18,10 +19,10 @@ export function useCurrentQuery() {
             ([item]: QueryItem[]) => {
                 dispatch({
                     type: UPDATE_QUERY,
-                    data: prepareQueryPlanIds(item),
+                    data: prepareQueryPlanIds(item, defaultQueryACO),
                 });
             },
-        [dispatch],
+        [dispatch, defaultQueryACO],
     );
 
     useEffect(

packages/ui/src/ui/pages/query-tracker/module/api.ts

@@ -10,7 +10,7 @@ import {getClusterConfigByName, getClusterProxy} from '../../../store/selectors/
 import {generateQuerySettings, generateQueryText} from '../utils/query_generate';
 import {RootState} from '../../../store/reducers';
 import {makeDirectDownloadPath} from '../../../utils/navigation';
-import {DEFAULT_QUERY_ACO, getQueryTrackerRequestOptions} from './query/selectors';
+import {getCurrentStage, getQueryTrackerRequestOptions} from './query/selectors';
 import {UPDATE_QUERIES_LIST} from './query-tracker-contants';
 import {AnyAction} from 'redux';
 import {QueryEngine} from './engines';
@@ -217,7 +217,7 @@ export type QueriesListRequestParams = {
 
 export async function generateQueryFromTable(
     engine: QueryEngine,
-    {cluster, path}: {cluster: string; path: string},
+    {cluster, path, defaultQueryACO}: {cluster: string; path: string; defaultQueryACO: string},
 ): Promise<DraftQuery | undefined> {
     const selectedCluster = getClusterConfigByName(cluster);
     const node = await ytApiV3.get({
@@ -244,8 +244,8 @@ export async function generateQueryFromTable(
             }),
             files: [],
             annotations: {},
-            access_control_object: DEFAULT_QUERY_ACO,
-            access_control_objects: [DEFAULT_QUERY_ACO],
+            access_control_object: defaultQueryACO,
+            access_control_objects: [defaultQueryACO],
             settings: generateQuerySettings(engine, cluster),
         };
     }
@@ -578,9 +578,10 @@ export function addACOToLastSelected(
         const state = getState();
         const cluster = state.global.cluster;
         const lastSelectedACONamespaces = getLastSelectedACONamespaces(state);
+        const stage = getCurrentStage(state);
 
         await dispatch(
-            setSettingByKey(`local::${cluster}::queryTracker::lastSelectedACOs`, [
+            setSettingByKey(`qt-stage::${cluster}::queryTracker::${stage}::lastSelectedACOs`, [
                 ...aco,
                 ...lastSelectedACONamespaces.filter((item) => !aco.includes(item)).slice(0, 9),
             ]),

packages/ui/src/ui/pages/query-tracker/module/query/actions.ts

@@ -16,9 +16,9 @@ import {
 } from '../api';
 import {requestQueriesList} from '../queries_list/actions';
 import {
-    DEFAULT_QUERY_ACO,
     SHARED_QUERY_ACO,
     getCurrentQuery,
+    getDefaultQueryACO,
     getQueryDraft,
     getQuery as selectQuery,
 } from './selectors';
@@ -151,7 +151,8 @@ export function loadQuery(
             });
 
             query.files = query.files.map((file) => ({...file, id: guid()}));
-            const queryItem = prepareQueryPlanIds(query);
+            const defaultQueryACO = getDefaultQueryACO(state);
+            const queryItem = prepareQueryPlanIds(query, defaultQueryACO);
 
             if (config?.dontReplaceQueryText) {
                 queryItem.query = state.queryTracker.query.draft.query;
@@ -191,11 +192,13 @@ export function createQueryFromTablePath(
     | UpdateQueryAction
     | SetQueryReadyAction
 > {
-    return async (dispatch) => {
+    return async (dispatch, getState) => {
         dispatch({type: REQUEST_QUERY});
         try {
+            const state = getState();
+            const defaultQueryACO = getDefaultQueryACO(state);
             const draft = await wrapApiPromiseByToaster(
-                generateQueryFromTable(engine, {cluster, path}),
+                generateQueryFromTable(engine, {cluster, path, defaultQueryACO}),
                 {
                     toasterName: 'load_query',
                     skipSuccessToast: true,
@@ -231,11 +234,16 @@ export function createEmptyQuery(
     query?: string,
     settings?: Record<string, string>,
 ): ThunkAction<any, RootState, any, SetQueryAction> {
-    return (dispatch) => {
+    return (dispatch, getState) => {
+        const state = getState();
+        const defaultQueryACO = getDefaultQueryACO(state);
+
         dispatch({
             type: SET_QUERY,
             data: {
                 initialQuery: {
+                    access_control_object: defaultQueryACO,
+                    access_control_objects: [defaultQueryACO],
                     query: query || '',
                     engine,
                     settings: settings || {},
@@ -358,11 +366,12 @@ export const toggleShareQuery =
         const query = selectQuery(state);
         if (!query) return;
 
-        let aco = query.access_control_objects || [DEFAULT_QUERY_ACO];
+        const defaultQueryACO = getDefaultQueryACO(state);
+        let aco = query.access_control_objects || [defaultQueryACO];
 
         if (aco.includes(SHARED_QUERY_ACO)) {
             aco = aco.filter((i) => i !== SHARED_QUERY_ACO);
-            if (!aco.length) aco = [DEFAULT_QUERY_ACO];
+            if (!aco.length) aco = [defaultQueryACO];
         } else {
             aco = [...aco, SHARED_QUERY_ACO];
         }

packages/ui/src/ui/pages/query-tracker/module/query/selectors.ts

@@ -1,4 +1,5 @@
 import forOwn_ from 'lodash/forOwn';
+import get_ from 'lodash/get';
 import {createSelector} from 'reselect';
 import {RootState} from '../../../../store/reducers';
 import {DraftQuery, QTRequestOptions, QueryItem, QueryStatus} from '../api';
@@ -12,6 +13,7 @@ import {YTError} from '../../../../types';
 import {isYTError} from '../../../../../shared/utils';
 import {getQueryResults} from '../query_result/selectors';
 import {selectIsMultipleAco} from '../query_aco/selectors';
+import {getClusterUiConfig} from '../../../../store/selectors/global';
 
 const QT_STAGE = getQueryTrackerStage();
 const getState = (state: RootState) => state.queryTracker.query;
@@ -101,18 +103,37 @@ export const getQueryEditorErrors = (state: RootState): QTEditorError[] => {
 export const getDirtySinceLastSubmit = (state: RootState) =>
     state.queryTracker.query.dirtySinceLastSubmit;
 
-const getAco = (isMultipleAco: boolean, state?: QueryItem | DraftQuery): string[] => {
-    if (isMultipleAco) return state?.access_control_objects ?? [DEFAULT_QUERY_ACO];
+export const getCurrentStage = (state: RootState) => {
+    return state.queryTracker?.aco?.data?.query_tracker_stage ?? 'production';
+};
+
+export const getDefaultQueryACO = (state: RootState) => {
+    const queryTrackerDefaultACO = getClusterUiConfig(state)?.query_tracker_default_aco;
+    const stage = getCurrentStage(state);
 
-    return state?.access_control_object ? [state?.access_control_object] : [DEFAULT_QUERY_ACO];
+    return get_(queryTrackerDefaultACO, stage, DEFAULT_QUERY_ACO);
+};
+
+const getAco = (
+    defaultACO: string,
+    isMultipleAco: boolean,
+    state?: QueryItem | DraftQuery,
+): string[] => {
+    if (isMultipleAco) return state?.access_control_objects ?? [defaultACO];
+
+    return state?.access_control_object ? [state?.access_control_object] : [defaultACO];
 };
 
 export const getCurrentQueryACO = (state: RootState) => {
-    return getAco(selectIsMultipleAco(state), state.queryTracker.query?.queryItem);
+    const defaultACO = getDefaultQueryACO(state);
+
+    return getAco(defaultACO, selectIsMultipleAco(state), state.queryTracker.query?.queryItem);
 };
 
 export const getCurrentDraftQueryACO = (state: RootState) => {
-    return getAco(selectIsMultipleAco(state), state.queryTracker.query?.draft);
+    const defaultACO = getDefaultQueryACO(state);
+
+    return getAco(defaultACO, selectIsMultipleAco(state), state.queryTracker.query?.draft);
 };
 
 export const getProgressYQLStatistics = (state: RootState) => {

packages/ui/src/ui/pages/query-tracker/module/query/utills.ts

@@ -1,6 +1,5 @@
 import {omit} from 'lodash';
 import {QueryItem} from '../api';
-import {DEFAULT_QUERY_ACO} from './selectors';
 
 export const cleanupQueryForDraft = (query: QueryItem): QueryItem => {
     return {
@@ -9,7 +8,7 @@ export const cleanupQueryForDraft = (query: QueryItem): QueryItem => {
     };
 };
 
-export const prepareQueryPlanIds = (query: QueryItem): QueryItem => {
+export const prepareQueryPlanIds = (query: QueryItem, defaultQueryACO: string): QueryItem => {
     const nodes = query.progress?.yql_plan?.Basic.nodes;
     const links = query.progress?.yql_plan?.Basic.links;
     const operations = query.progress?.yql_plan?.Detailed?.Operations;
@@ -34,7 +33,7 @@ export const prepareQueryPlanIds = (query: QueryItem): QueryItem => {
     }
 
     if (!query.access_control_objects) {
-        query.access_control_objects = [DEFAULT_QUERY_ACO];
+        query.access_control_objects = [defaultQueryACO];
     }
 
     return query;

packages/ui/src/ui/pages/query-tracker/module/query_aco/reducer.ts

@@ -5,6 +5,7 @@ export interface QueryACOState {
     data: {
         cluster_name: string;
         access_control_objects: string[];
+        query_tracker_stage: string;
         supported_features: {access_control: boolean; multiple_aco?: boolean};
     };
     loading: boolean;
@@ -16,6 +17,7 @@ const initialState: QueryACOState = {
     data: {
         cluster_name: '',
         access_control_objects: [],
+        query_tracker_stage: 'production',
         supported_features: {
             access_control: false,
         },

packages/ui/src/ui/pages/query-tracker/module/query_aco/selectors.ts

@@ -3,13 +3,17 @@ import {SelectOption} from '@gravity-ui/uikit/build/esm/components/Select/types'
 import {RootState} from '../../../../store/reducers';
 import {getSettingsData} from '../../../../store/selectors/settings-base';
 import {createSelector} from 'reselect';
-import {SHARED_QUERY_ACO} from '../query/selectors';
+import {SHARED_QUERY_ACO, getCurrentStage} from '../query/selectors';
 const selectAcoState = (state: RootState) => state.queryTracker.aco;
 
 export const getLastSelectedACONamespaces = (state: RootState) => {
     const cluster = state.global.cluster;
+    const stage = getCurrentStage(state);
 
-    return getSettingsData(state)[`local::${cluster}::queryTracker::lastSelectedACOs`] ?? [];
+    return (
+        getSettingsData(state)[`qt-stage::${cluster}::queryTracker::${stage}::lastSelectedACOs`] ??
+        []
+    );
 };
 
 export const getQueryACOOptions = (state: RootState): SelectOption[] => {