@finos/legend-application-data-cube 0.1.2 → 0.1.4

package/src/components/DataCubeEditor.tsx

@@ -15,11 +15,94 @@
  */
 
 import { observer } from 'mobx-react-lite';
-import { QuestionIcon } from '@finos/legend-art';
+import {
+  Dialog,
+  Modal,
+  ModalBody,
+  ModalFooter,
+  ModalFooterButton,
+  ModalHeader,
+  PanelListItem,
+  PanelLoadingIndicator,
+  QuestionIcon,
+  clsx,
+} from '@finos/legend-art';
 import { useLegendDataCubeBaseStore } from './LegendDataCubeFrameworkProvider.js';
 import { DataCubeSourceEditor } from './source/DataCubeSourceEditor.js';
-import { useEffect } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { DataCube } from '@finos/legend-data-cube';
+import type { LegendDataCubeStore } from '../stores/LegendDataCubeEditorStore.js';
+import type { LegendCubeViewer } from '../stores/source/LegendCubeViewer.js';
+import { flowResult } from 'mobx';
+
+const CreateQueryDialog = observer(
+  (props: { view: LegendCubeViewer; store: LegendDataCubeStore }) => {
+    const { store } = props;
+    const close = (): void => store.setSaveModal(false);
+    const [queryName, setQueryName] = useState('');
+    const create = (): void => {
+      flowResult(store.saveQuery(queryName)).catch(
+        store.applicationStore.alertUnhandledError,
+      );
+    };
+    const isEmptyName = !queryName;
+    // name
+    const nameInputRef = useRef<HTMLInputElement>(null);
+    const setFocus = (): void => {
+      nameInputRef.current?.focus();
+    };
+
+    const changeName: React.ChangeEventHandler<HTMLInputElement> = (event) => {
+      setQueryName(event.target.value);
+    };
+
+    useEffect(() => {
+      setTimeout(() => setFocus(), 1);
+    }, []);
+    return (
+      <Dialog
+        open={store.saveModal}
+        onClose={close}
+        classes={{
+          root: 'editor-modal__root-container',
+          container: 'editor-modal__container',
+          paper: 'editor-modal__content',
+        }}
+      >
+        <Modal darkMode={false} className="query-export">
+          <ModalHeader title="Create New Query" />
+          <ModalBody>
+            <PanelLoadingIndicator
+              isLoading={store.saveModalState.isInProgress}
+            />
+            <PanelListItem>
+              <div className="input--with-validation">
+                <input
+                  ref={nameInputRef}
+                  className={clsx('input input--dark', {
+                    'input--caution': false,
+                  })}
+                  spellCheck={false}
+                  value={queryName}
+                  onChange={changeName}
+                  title="New Query Name"
+                />
+              </div>
+            </PanelListItem>
+          </ModalBody>
+          <ModalFooter>
+            <ModalFooterButton
+              text="Create Query"
+              title="Create new query"
+              disabled={isEmptyName}
+              onClick={create}
+            />
+          </ModalFooter>
+        </Modal>
+      </Dialog>
+    );
+  },
+);
 
 export const DataCubeEditor = observer(() => {
   const dataCubeStore = useLegendDataCubeBaseStore();
@@ -55,7 +138,15 @@ export const DataCubeEditor = observer(() => {
         {dataCubeStore.cubeViewer ? (
           <>
             <div className="h-[calc(100%_-_30px)]">
-              <div className="h-12 w-full bg-gray-200"></div>
+              <div className="h-12 w-full bg-gray-200">
+                <button
+                  onClick={() => dataCubeStore.setSaveModal(true)}
+                  type="button"
+                  className="relative rounded-full bg-sky-900 p-1 text-gray-400 hover:text-white focus:outline-none focus:ring-2 focus:ring-white focus:ring-offset-2 focus:ring-offset-gray-800"
+                >
+                  Save
+                </button>
+              </div>
               <div className="h-[calc(100%_-_30px)]">
                 <DataCube engine={dataCubeStore.cubeViewer.engine} />
               </div>
@@ -88,6 +179,12 @@ export const DataCubeEditor = observer(() => {
       {sourceSelector.open && (
         <DataCubeSourceEditor sourceBuilder={sourceSelector} />
       )}
+      {dataCubeStore.cubeViewer && dataCubeStore.saveModal && (
+        <CreateQueryDialog
+          store={dataCubeStore}
+          view={dataCubeStore.cubeViewer}
+        />
+      )}
     </>
   );
 });

package/src/components/LegendDataCubeWebApplication.tsx

@@ -19,12 +19,18 @@ import { Route, Routes } from '@finos/legend-application/browser';
 import { LegendDataCubeFrameworkProvider } from './LegendDataCubeFrameworkProvider.js';
 import { observer } from 'mobx-react-lite';
 import { DataCubeEditor } from './DataCubeEditor.js';
+import { ExistingDataCubeQuery } from './source/ExistingDataCubeQuery.js';
+import { LEGEND_DATA_CUBE_ROUTE_PATTERN } from '../__lib__/LegendDataCubeNavigation.js';
 
 const LegendDataCubeWebApplicationRouter = observer(() => {
   return (
     <div className="app">
       <Routes>
-        <Route path="*" element={<DataCubeEditor />} />
+        <Route
+          path={LEGEND_DATA_CUBE_ROUTE_PATTERN.VIEW_EXISTING_QUERY}
+          element={<ExistingDataCubeQuery />}
+        />
+        <Route path="/" element={<DataCubeEditor />} />
       </Routes>
     </div>
   );

package/src/components/source/DataCubeSourceEditor.tsx

@@ -28,8 +28,8 @@ import { SavedQuerySourceEditor } from './SavedQuerySourceEditor.js';
 import { SavedQueryInputSourceState } from '../../stores/source/SavedQueryInputSourceState.js';
 import { useLegendDataCubeBaseStore } from '../LegendDataCubeFrameworkProvider.js';
 import { flowResult } from 'mobx';
-import type { CubeInputSource } from '../../stores/source/CubeInputSource.js';
 import type { DataCubeEngine } from '@finos/legend-data-cube';
+import type { DataCubeGenericSource } from '../../stores/model/DataCubeGenericSource.js';
 
 export const DataCubeSourceEditor = observer(
   (props: { sourceBuilder: LegendDataCubeSourceBuilder }) => {
@@ -111,7 +111,7 @@ export const DataCubeSourceEditor = observer(
               onClick={() => {
                 flowResult(
                   sourceBuilder.inputSource(
-                    (source: CubeInputSource, engine: DataCubeEngine) =>
+                    (source: DataCubeGenericSource, engine: DataCubeEngine) =>
                       store.initializeView(source, engine),
                   ),
                 ).catch(store.context.applicationStore.alertUnhandledError);

package/src/components/source/ExistingDataCubeQuery.tsx

@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { observer } from 'mobx-react-lite';
+import { useLegendDataCubeBaseStore } from '../LegendDataCubeFrameworkProvider.js';
+import { useEffect } from 'react';
+import { QuestionIcon } from '@finos/legend-art';
+import { useParams } from '@finos/legend-application/browser';
+import { DataCube } from '@finos/legend-data-cube';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  LEGEND_DATA_CUBE_ROUTE_PATTERN_TOKEN,
+  type ExistingDataCubeViewerPathParams,
+} from '../../__lib__/LegendDataCubeNavigation.js';
+import { flowResult } from 'mobx';
+
+export const ExistingDataCubeQuery = observer(() => {
+  const dataCubeStore = useLegendDataCubeBaseStore();
+  const params = useParams<ExistingDataCubeViewerPathParams>();
+  const sourceSelector = dataCubeStore.sourceSelector;
+  const queryId = guaranteeNonNullable(
+    params[LEGEND_DATA_CUBE_ROUTE_PATTERN_TOKEN.DATA_CUBE_QUERY_ID],
+  );
+  useEffect(() => {
+    flowResult(dataCubeStore.initialize(queryId)).catch(
+      dataCubeStore.applicationStore.alertUnhandledError,
+    );
+  }, [dataCubeStore, queryId]);
+
+  return (
+    <>
+      <div className="h-full w-full bg-white">
+        <div className="bg-sky-900">
+          <div className="mx-auto max-w-full px-2 sm:px-6 lg:px-8">
+            <div className="relative flex h-12 items-center justify-between">
+              <div className="flex flex-1 items-center justify-center sm:items-stretch sm:justify-start">
+                <div className="flex flex-shrink-0 items-center">
+                  <div className="text-gray-300">Legend Data Cube</div>
+                </div>
+              </div>
+              <div className="md:block">
+                <div className="ml-4 flex items-center md:ml-6">
+                  <button
+                    type="button"
+                    className="relative rounded-full bg-sky-900 p-1 text-gray-400 hover:text-white focus:outline-none focus:ring-2 focus:ring-white focus:ring-offset-2 focus:ring-offset-gray-800"
+                  >
+                    <QuestionIcon />
+                  </button>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        {dataCubeStore.cubeViewer ? (
+          <>
+            <div className="h-[calc(100%_-_30px)]">
+              <div className="h-[calc(100%_-_30px)]">
+                <DataCube engine={dataCubeStore.cubeViewer.engine} />
+              </div>
+            </div>
+          </>
+        ) : (
+          <>
+            <div
+              onClick={() => sourceSelector.openModal()}
+              className="bg-white shadow"
+            >
+              <div className="mx-auto h-40 px-4 py-6 sm:px-6 lg:px-8">
+                <div className="group flex w-full flex-col items-center justify-center rounded-md border-2 border-dashed border-slate-300 py-3 text-base font-medium leading-6 text-slate-900 hover:cursor-pointer hover:border-solid hover:border-blue-500 hover:bg-white hover:text-blue-500">
+                  <svg
+                    className="mb-1 text-slate-400 group-hover:text-blue-500"
+                    width="20"
+                    height="20"
+                    fill="currentColor"
+                    aria-hidden="true"
+                  >
+                    <path d="M10 5a1 1 0 0 1 1 1v3h3a1 1 0 1 1 0 2h-3v3a1 1 0 1 1-2 0v-3H6a1 1 0 1 1 0-2h3V6a1 1 0 0 1 1-1Z" />
+                  </svg>
+                  Add Source
+                </div>
+              </div>
+            </div>
+          </>
+        )}
+      </div>
+    </>
+  );
+});

package/src/components/source/SavedQuerySourceEditor.tsx

@@ -29,7 +29,7 @@ export const SavedQuerySourceEditor = observer(
         {savedQuery ? (
           <div className="p-3">
             <div className="text-l font-bold">Saved Query</div>
-            <div className="">
+            <div>
               <div className="flex pt-px">
                 <div className="font-bold">Name:</div>
                 <div>{savedQuery.name}</div>

package/src/stores/LegendDataCubeEditorStore.ts

@@ -19,19 +19,36 @@ import {
   type ApplicationStore,
 } from '@finos/legend-application';
 import type { LegendDataCubePluginManager } from '../application/LegendDataCubePluginManager.js';
-import { DepotServerClient } from '@finos/legend-server-depot';
+import { DepotServerClient, resolveVersion } from '@finos/legend-server-depot';
 import type { LegendDataCubeApplicationConfig } from '../application/LegendDataCubeApplicationConfig.js';
-import { GraphManagerState } from '@finos/legend-graph';
+import {
+  GraphManagerState,
+  LegendSDLC,
+  PersistentDataCubeQuery,
+  type QueryInfo,
+  type RawLambda,
+} from '@finos/legend-graph';
 import { LegendDataCubeSourceBuilder } from './source/LegendDataCubeSourceBuilder.js';
 import {
   ActionState,
+  UnsupportedOperationError,
   assertErrorThrown,
+  guaranteeNonNullable,
+  uuid,
   type GeneratorFn,
 } from '@finos/legend-shared';
-import { action, flow, makeObservable, observable } from 'mobx';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
 import { LegendCubeViewer } from './source/LegendCubeViewer.js';
-import type { CubeInputSource } from './source/CubeInputSource.js';
 import type { DataCubeEngine } from '@finos/legend-data-cube';
+import type { DataCubeGenericSource } from './model/DataCubeGenericSource.js';
+import {
+  createQueryBuilderContent,
+  deserializeDataCubeQueryConent,
+  serializeDataCubeQueryConent,
+} from './model/DataCubeGenericSourceHelper.js';
+import { LegendSavedQuerySource } from './model/LegendSavedQuerySource.js';
+import { LegendExecutionDataCubeEngine } from './engine/LegendExecutionDataCubeEngine.js';
+import { generatedSavedQueryUrl } from '../__lib__/LegendDataCubeNavigation.js';
 
 export type LegendDataCubeApplicationStore = ApplicationStore<
   LegendDataCubeApplicationConfig,
@@ -99,14 +116,24 @@ export class LegendDataCubeStore {
   readonly applicationStore: LegendDataCubeApplicationStore;
   readonly context: LegendDataCubeStoreContext;
   readonly pluginManager: LegendDataCubePluginManager;
+
   sourceSelector: LegendDataCubeSourceBuilder;
   cubeViewer: LegendCubeViewer | undefined;
+  saveModal = false;
+  saveModalState = ActionState.create();
+  savedQuery: PersistentDataCubeQuery | undefined;
 
   constructor(applicationStore: LegendDataCubeApplicationStore) {
     makeObservable(this, {
       cubeViewer: observable,
       sourceSelector: observable,
+      saveModal: observable,
+      setSaveModal: observable,
+      saveModalState: observable,
+      savedQuery: observable,
       initializeView: action,
+      initialize: flow,
+      saveQuery: flow,
     });
     this.applicationStore = applicationStore;
     this.pluginManager = applicationStore.pluginManager;
@@ -114,7 +141,97 @@ export class LegendDataCubeStore {
     this.sourceSelector = new LegendDataCubeSourceBuilder(this.context);
   }
 
-  initializeView(source: CubeInputSource, engine: DataCubeEngine): void {
+  setSaveModal(val: boolean): void {
+    this.saveModal = val;
+  }
+
+  initializeView(source: DataCubeGenericSource, engine: DataCubeEngine): void {
     this.cubeViewer = new LegendCubeViewer(source, engine);
   }
+
+  *initialize(id: string): GeneratorFn<void> {
+    try {
+      yield flowResult(this.context.initialize());
+      const query =
+        (yield this.context.graphManagerState.graphManager.getDataCubeQuery(
+          id,
+        )) as unknown as PersistentDataCubeQuery;
+      this.savedQuery = query;
+      const source = deserializeDataCubeQueryConent(query.content).source;
+      if (source instanceof LegendSavedQuerySource) {
+        const queryInfo =
+          (yield this.context.graphManagerState.graphManager.getQueryInfo(
+            source.id,
+          )) as unknown as QueryInfo;
+        const execConext =
+          (yield this.context.graphManagerState.graphManager.resolveQueryInfoExecutionContext(
+            queryInfo,
+            () =>
+              this.context.depotServerClient.getVersionEntities(
+                queryInfo.groupId,
+                queryInfo.artifactId,
+                queryInfo.versionId,
+              ),
+          )) as { mapping: string | undefined; runtime: string };
+        const lambda =
+          (yield this.context.graphManagerState.graphManager.pureCodeToLambda(
+            queryInfo.content,
+          )) as unknown as RawLambda;
+        this.context.graphManagerState.graph.setOrigin(
+          new LegendSDLC(
+            queryInfo.groupId,
+            queryInfo.artifactId,
+            resolveVersion(queryInfo.versionId),
+          ),
+        );
+        // TODO: we should be able to call engine and convert lambda to relation if not one.
+        const engine = new LegendExecutionDataCubeEngine(
+          lambda,
+          undefined,
+          execConext.mapping,
+          execConext.runtime,
+          this.context.graphManagerState,
+        );
+        this.initializeView(source, engine);
+      } else {
+        throw new UnsupportedOperationError('not supported');
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(
+        `Unable to initialie query with id '${id}'`,
+      );
+    }
+  }
+
+  *saveQuery(name: string): GeneratorFn<void> {
+    try {
+      this.saveModalState.inProgress();
+      const view = guaranteeNonNullable(this.cubeViewer);
+      const content = serializeDataCubeQueryConent(
+        createQueryBuilderContent(view.source),
+      );
+      const cubeQuery = new PersistentDataCubeQuery();
+      cubeQuery.content = content;
+      cubeQuery.name = name;
+      cubeQuery.id = uuid();
+      const querySaved =
+        (yield this.context.graphManagerState.graphManager.createQueryDataCube(
+          cubeQuery,
+        )) as unknown as PersistentDataCubeQuery;
+      this.savedQuery = querySaved;
+      // TODO: fix reload
+      this.applicationStore.navigationService.navigator.goToLocation(
+        generatedSavedQueryUrl(querySaved.id),
+      );
+      this.setSaveModal(false);
+      this.saveModalState.complete();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.saveModalState.fail();
+      this.applicationStore.notificationService.notifyError(
+        `Unable to save query`,
+      );
+    }
+  }
 }

package/src/stores/engine/LegendExecutionDataCubeEngine.ts

@@ -37,12 +37,16 @@ import {
   DataCubeSource,
   type RelationType,
   DataCubeQuery,
-  type DataCubeInitialInput,
   type CompletionItem,
   _function,
   DataCubeFunction,
 } from '@finos/legend-data-cube';
-import { guaranteeType, isNonNullable, LogService } from '@finos/legend-shared';
+import {
+  guaranteeType,
+  isNonNullable,
+  LogService,
+  type PlainObject,
+} from '@finos/legend-shared';
 
 class QueryBuilderDataCubeSource extends DataCubeSource {
   mapping?: string | undefined;
@@ -77,11 +81,11 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     return `Query Builder Report`;
   }
 
-  override getInitialInput(): Promise<DataCubeInitialInput> {
-    return this.buildBaseQuery();
+  get graph(): PureModel {
+    return this.graphState.graph;
   }
 
-  async buildBaseQuery(): Promise<DataCubeInitialInput> {
+  private getSourceFunctionExpression() {
     let srcFuncExp = V1_deserializeValueSpecification(
       this.graphState.graphManager.serializeRawValueSpecification(
         this.selectInitialQuery,
@@ -97,6 +101,11 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     ) {
       srcFuncExp = srcFuncExp.body[0];
     }
+    return srcFuncExp;
+  }
+
+  async getBaseQuery() {
+    const srcFuncExp = this.getSourceFunctionExpression();
     this._parameters = this.selectInitialQuery.parameters;
     const fromFuncExp = new V1_AppliedFunction();
     fromFuncExp.function = _functionName(SUPPORTED_FUNCTIONS.FROM);
@@ -111,19 +120,20 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
       .columns;
     const query = new DataCubeQuery();
     query.query = `~[${columns.map((e) => `'${e.name}'`)}]->select()`;
+
+    return query;
+  }
+
+  async processQuerySource(value: PlainObject) {
+    const srcFuncExp = this.getSourceFunctionExpression();
+    const columns = (await this.getRelationalType(this.selectInitialQuery))
+      .columns;
     const source = new QueryBuilderDataCubeSource();
     source.sourceColumns = columns;
     source.mapping = this.mappingPath;
     source.runtime = this.runtimePath;
     source.query = srcFuncExp;
-    return {
-      query,
-      source,
-    };
-  }
-
-  get graph(): PureModel {
-    return this.graphState.graph;
+    return source;
   }
 
   private buildRawLambdaFromValueSpec(query: V1_Lambda): RawLambda {
@@ -156,7 +166,7 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     return result.completions as CompletionItem[];
   }
 
-  override async parseValueSpecification(
+  async parseValueSpecification(
     code: string,
     returnSourceInformation?: boolean,
   ) {
@@ -169,7 +179,7 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     );
   }
 
-  override getValueSpecificationCode(
+  async getValueSpecificationCode(
     value: V1_ValueSpecification,
     pretty?: boolean | undefined,
   ) {
@@ -188,12 +198,12 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     return relationType;
   }
 
-  override getQueryRelationType(query: V1_Lambda, source: DataCubeSource) {
+  async getQueryRelationType(query: V1_Lambda, source: DataCubeSource) {
     const lambda = this.buildRawLambdaFromValueSpec(query);
     return this.getRelationalType(lambda);
   }
 
-  override async getQueryCodeRelationReturnType(
+  async getQueryCodeRelationReturnType(
     code: string,
     baseQuery: V1_ValueSpecification,
     source: DataCubeSource,
@@ -208,7 +218,7 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     );
   }
 
-  override async executeQuery(query: V1_Lambda, source: DataCubeSource) {
+  async executeQuery(query: V1_Lambda, source: DataCubeSource) {
     const lambda = this.buildRawLambdaFromValueSpec(query);
     lambda.parameters = this._parameters;
     const [executionWithMetadata, queryString] = await Promise.all([
@@ -240,7 +250,7 @@ export class LegendExecutionDataCubeEngine extends DataCubeEngine {
     };
   }
 
-  override buildExecutionContext(
+  buildExecutionContext(
     source: DataCubeSource,
   ): V1_AppliedFunction | undefined {
     if (source instanceof QueryBuilderDataCubeSource) {

package/src/stores/model/DataCubeGenericSource.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export abstract class DataCubeGenericSource {}

package/src/stores/model/DataCubeGenericSourceHelper.ts

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  UnsupportedOperationError,
+  optionalCustom,
+  usingConstantValueSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import type { DataCubeGenericSource } from './DataCubeGenericSource.js';
+import { LegendSavedQuerySource } from './LegendSavedQuerySource.js';
+import {
+  createModelSchema,
+  primitive,
+  deserialize,
+  serialize,
+  optional,
+  raw,
+} from 'serializr';
+import { DataCubeQueryConent } from './DataCubeQueryContent.js';
+
+enum SavedDataCubeQueryType {
+  LEGEND_QUERY = 'LegendQuery',
+}
+
+export const legendSavedQuerySourceModelSchema = createModelSchema(
+  LegendSavedQuerySource,
+  {
+    _type: usingConstantValueSchema(SavedDataCubeQueryType.LEGEND_QUERY),
+    id: primitive(),
+  },
+);
+
+const deserializeDataCubeGenericSource = (
+  content: PlainObject<object>,
+): DataCubeGenericSource => {
+  switch (content._type) {
+    case SavedDataCubeQueryType.LEGEND_QUERY:
+      return deserialize(legendSavedQuerySourceModelSchema, content);
+    default:
+  }
+  throw new UnsupportedOperationError(
+    `Can't de serialize saved data cube`,
+    content._type,
+  );
+};
+
+const serializeDataCubeGenericSource = (
+  genericSource: DataCubeGenericSource,
+): PlainObject<DataCubeGenericSource> => {
+  if (genericSource instanceof LegendSavedQuerySource) {
+    return serialize(legendSavedQuerySourceModelSchema, genericSource);
+  }
+  throw new UnsupportedOperationError(`Can't serialize saved data cube`);
+};
+
+const dataCubeQueryConentModelSchema = createModelSchema(DataCubeQueryConent, {
+  query: optional(primitive()),
+  configuration: optional(raw()),
+  source: optionalCustom(
+    (val) => serializeDataCubeGenericSource(val),
+    (val) => deserializeDataCubeGenericSource(val),
+  ),
+});
+
+export const createQueryBuilderContent = (
+  source: DataCubeGenericSource,
+): DataCubeQueryConent => {
+  const content = new DataCubeQueryConent();
+  content.source = source;
+  return content;
+};
+
+export const serializeDataCubeQueryConent = (
+  content: DataCubeQueryConent,
+): PlainObject<DataCubeQueryConent> => {
+  return serialize(dataCubeQueryConentModelSchema, content);
+};
+
+export const deserializeDataCubeQueryConent = (
+  content: PlainObject<DataCubeQueryConent>,
+): DataCubeQueryConent => {
+  return deserialize(dataCubeQueryConentModelSchema, content);
+};