add isUniqueValuesLoading to dataset header column

src/lib/dataset/index.ts

@@ -12,6 +12,7 @@ export type ColumnTypeMapping = {
 export type DataSetColumn = {
   name: string;
   type?: DataSetColumnType;
+  isUniqueValueLoading?: boolean; //It will be updated by backendify function
 };
 
 /**

src/store/backend-plugin.ts

@@ -9,7 +9,7 @@
  */
 import { Store } from 'vuex';
 
-import { BackendResponse } from '@/lib/backend-response';
+import { BackendError, BackendResponse } from '@/lib/backend-response';
 import { DataSet } from '@/lib/dataset';
 import { pageOffset } from '@/lib/dataset/pagination';
 import { Pipeline } from '@/lib/steps';
@@ -114,32 +114,54 @@ function _preparePipeline(pipeline: Pipeline, store: Store<any>) {
  *   - logs the error in the store if any,
  *   - sets the `loading: false` property on the store at the end.
  */
-export function backendify(target: Function) {
+export function backendify(
+  target: Function,
+  callFront?: Function,
+  callBack?: Function,
+  reject?: Function,
+) {
   return async function(this: BackendService | void, store: Store<any>, ...args: any[]) {
     try {
-      store.commit(VQBnamespace('setLoading'), { isLoading: true });
+      if (callFront) {
+        callFront();
+      }
       const response = await target.bind(this)(store, ...args);
       if (response.error) {
-        store.commit(VQBnamespace('logBackendError'), {
-          backendError: response.error,
-        });
+        if (reject) {
+          reject(response.error);
+        }
       }
       return response;
     } catch (error) {
       const response = { error: { type: 'error', message: error.toString() } };
-      store.commit(VQBnamespace('logBackendError'), {
-        backendError: response.error,
-      });
+      if (reject) {
+        reject(response.error);
+      }
       return response;
     } finally {
-      store.commit(VQBnamespace('setLoading'), { isLoading: false });
+      if (callBack) {
+        callBack();
+      }
     }
   };
 }
 
 async function _updateDataset(store: Store<any>, service: BackendService, pipeline: Pipeline) {
   pipeline = _preparePipeline(pipeline, store);
-  const response = await backendify(service.executePipeline).bind(service)(
+  const response = await backendify(
+    service.executePipeline,
+    () => {
+      store.commit(VQBnamespace('setLoading'), { isLoading: true });
+    },
+    () => {
+      store.commit(VQBnamespace('setLoading'), { isLoading: false });
+    },
+    (error: BackendError) => {
+      store.commit(VQBnamespace('logBackendError'), {
+        backendError: error,
+      });
+    },
+  ).bind(service)(
     store,
     pipeline,
     store.state[VQB_MODULE_NAME].pagesize,

src/store/getters.ts

@@ -82,6 +82,12 @@ const getters: GetterTree<VQBState, any> = {
    */
   pageno: (state: VQBState) =>
     state.dataset.paginationContext ? state.dataset.paginationContext.pageno : 1,
+  /**
+   * helper that is True if unique values are loading
+   */
+  isUniqueValuesLoading: (state: VQBState) => (column: string) =>
+    state.dataset.headers[state.dataset.headers.map(col => col.name).indexOf(column)]
+      .isUniqueValueLoading,
   /**
    * Return current edited pipeline
    */

src/store/mutations.ts

@@ -284,6 +284,18 @@ class Mutations {
     state.isLoading = isLoading;
   }
 
+  /**
+   * Set unique values loading
+   */
+  setUniqueValuesLoading(
+    state: VQBState,
+    { isLoading, column }: { isLoading: boolean; column: string },
+  ) {
+    state.dataset.headers[
+      state.dataset.headers.map(col => col.name).indexOf(column)
+    ].isUniqueValueLoading = isLoading;
+  }
+
   /**
    * Update translator.
    */