@finos/legend-data-cube 0.0.2

package/src/stores/engine/DataCubeEngine.ts

@@ -0,0 +1,276 @@
+/**
+ * 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 {
+  type V1_ValueSpecification,
+  type V1_Lambda,
+  type TDSExecutionResult,
+  V1_deserializeValueSpecification,
+  V1_serializeValueSpecification,
+} from '@finos/legend-graph';
+import { getFilterOperation } from '../core/filter/DataCubeQueryFilterOperation.js';
+import { getAggregateOperation } from '../core/aggregation/DataCubeQueryAggregateOperation.js';
+import { DataCubeQueryAggregateOperation__Sum } from '../core/aggregation/DataCubeQueryAggregateOperation__Sum.js';
+import { DataCubeQueryAggregateOperation__Average } from '../core/aggregation/DataCubeQueryAggregateOperation__Average.js';
+import { DataCubeQueryAggregateOperation__Count } from '../core/aggregation/DataCubeQueryAggregateOperation__Count.js';
+import { DataCubeQueryAggregateOperation__Min } from '../core/aggregation/DataCubeQueryAggregateOperation__Min.js';
+import { DataCubeQueryAggregateOperation__Max } from '../core/aggregation/DataCubeQueryAggregateOperation__Max.js';
+import { DataCubeQueryAggregateOperation__UniqueValue } from '../core/aggregation/DataCubeQueryAggregateOperation__UniqueValue.js';
+import { DataCubeQueryAggregateOperation__First } from '../core/aggregation/DataCubeQueryAggregateOperation__First.js';
+import { DataCubeQueryAggregateOperation__Last } from '../core/aggregation/DataCubeQueryAggregateOperation__Last.js';
+import { DataCubeQueryAggregateOperation__VariancePopulation } from '../core/aggregation/DataCubeQueryAggregateOperation__VariancePopulation.js';
+import { DataCubeQueryAggregateOperation__VarianceSample } from '../core/aggregation/DataCubeQueryAggregateOperation__VarianceSample.js';
+import { DataCubeQueryAggregateOperation__StdDevPopulation } from '../core/aggregation/DataCubeQueryAggregateOperation__StdDevPopulation.js';
+import { DataCubeQueryAggregateOperation__StdDevSample } from '../core/aggregation/DataCubeQueryAggregateOperation__StdDevSample.js';
+import { DataCubeQueryAggregateOperation__JoinStrings } from '../core/aggregation/DataCubeQueryAggregateOperation__JoinStrings.js';
+import { DataCubeQueryFilterOperation__Equal } from '../core/filter/DataCubeQueryFilterOperation__Equal.js';
+import { DataCubeQueryFilterOperation__LessThanOrEqual } from '../core/filter/DataCubeQueryFilterOperation__LessThanOrEqual.js';
+import { DataCubeQueryFilterOperation__LessThan } from '../core/filter/DataCubeQueryFilterOperation__LessThan.js';
+import { DataCubeQueryFilterOperation__GreaterThanOrEqual } from '../core/filter/DataCubeQueryFilterOperation__GreaterThanOrEqual.js';
+import { DataCubeQueryFilterOperation__GreaterThan } from '../core/filter/DataCubeQueryFilterOperation__GreaterThan.js';
+import { DataCubeQueryFilterOperation__NotEqual } from '../core/filter/DataCubeQueryFilterOperation__NotEqual.js';
+import { DataCubeQueryFilterOperation__EqualColumn } from '../core/filter/DataCubeQueryFilterOperation__EqualColumn.js';
+import { DataCubeQueryFilterOperation__EqualCaseInsensitive } from '../core/filter/DataCubeQueryFilterOperation__EqualCaseInsensitive.js';
+import { DataCubeQueryFilterOperation__NotEqualCaseInsensitive } from '../core/filter/DataCubeQueryFilterOperation__NotEqualCaseInsensitive.js';
+import { DataCubeQueryFilterOperation__EqualCaseInsensitiveColumn } from '../core/filter/DataCubeQueryFilterOperation__EqualCaseInsensitiveColumn.js';
+import { DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn } from '../core/filter/DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn.js';
+import { DataCubeQueryFilterOperation__NotEqualColumn } from '../core/filter/DataCubeQueryFilterOperation__NotEqualColumn.js';
+import { DataCubeQueryFilterOperation__LessThanColumn } from '../core/filter/DataCubeQueryFilterOperation__LessThanColumn.js';
+import { DataCubeQueryFilterOperation__LessThanOrEqualColumn } from '../core/filter/DataCubeQueryFilterOperation__LessThanOrEqualColumn.js';
+import { DataCubeQueryFilterOperation__GreaterThanColumn } from '../core/filter/DataCubeQueryFilterOperation__GreaterThanColumn.js';
+import { DataCubeQueryFilterOperation__GreaterThanOrEqualColumn } from '../core/filter/DataCubeQueryFilterOperation__GreaterThanOrEqualColumn.js';
+import { DataCubeQueryFilterOperation__Contain } from '../core/filter/DataCubeQueryFilterOperation__Contain.js';
+import { DataCubeQueryFilterOperation__ContainCaseInsensitive } from '../core/filter/DataCubeQueryFilterOperation__ContainCaseInsensitive.js';
+import { DataCubeQueryFilterOperation__NotContain } from '../core/filter/DataCubeQueryFilterOperation__NotContain.js';
+import { DataCubeQueryFilterOperation__StartWith } from '../core/filter/DataCubeQueryFilterOperation__StartWith.js';
+import { DataCubeQueryFilterOperation__StartWithCaseInsensitive } from '../core/filter/DataCubeQueryFilterOperation__StartWithCaseInsensitive.js';
+import { DataCubeQueryFilterOperation__NotStartWith } from '../core/filter/DataCubeQueryFilterOperation__NotStartWith.js';
+import { DataCubeQueryFilterOperation__EndWith } from '../core/filter/DataCubeQueryFilterOperation__EndWith.js';
+import { DataCubeQueryFilterOperation__EndWithCaseInsensitive } from '../core/filter/DataCubeQueryFilterOperation__EndWithCaseInsensitive.js';
+import { DataCubeQueryFilterOperation__NotEndWith } from '../core/filter/DataCubeQueryFilterOperation__NotEndWith.js';
+import { DataCubeQueryFilterOperation__IsNull } from '../core/filter/DataCubeQueryFilterOperation__IsNull.js';
+import { DataCubeQueryFilterOperation__IsNotNull } from '../core/filter/DataCubeQueryFilterOperation__IsNotNull.js';
+import type { DataCubeViewState } from '../DataCubeViewState.js';
+import { LicenseManager } from '@ag-grid-enterprise/core';
+import {
+  configureCodeEditor,
+  setupPureLanguageService,
+} from '@finos/legend-code-editor';
+import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
+import { createModelSchema, custom, primitive } from 'serializr';
+import { type DataCubeQueryColumn, DataCubeQuery } from './DataCubeQuery.js';
+import { DataCubeFont } from '../core/DataCubeQueryEngine.js';
+
+export type CompletionItem = {
+  completion: string;
+  display: string;
+};
+
+export type DataCubeQueryBuilderError = {
+  type: string;
+  message: string;
+  sourceInformation?: {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+  };
+};
+
+export type DataCubeInfrastructureInfo = {
+  gridClientLicense?: string | undefined;
+};
+
+export type RelationType = {
+  columns: DataCubeQueryColumn[];
+};
+
+export class DataCubeGetBaseQueryResult {
+  query!: DataCubeQuery;
+  timestamp!: number;
+  partialQuery!: V1_ValueSpecification;
+  sourceQuery!: V1_ValueSpecification;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeGetBaseQueryResult, {
+      partialQuery: custom(
+        (val) => V1_serializeValueSpecification(val, []),
+        (val) => V1_deserializeValueSpecification(val, []),
+      ),
+      query: usingModelSchema(DataCubeQuery.serialization.schema),
+      sourceQuery: custom(
+        (val) => V1_serializeValueSpecification(val, []),
+        (val) => V1_deserializeValueSpecification(val, []),
+      ),
+      timestamp: primitive(),
+    }),
+  );
+}
+
+export const DEFAULT_ENABLE_DEBUG_MODE = false;
+export const DEFAULT_ENABLE_ENGINE_DEBUG_MODE = false;
+
+export const DEFAULT_GRID_CLIENT_ROW_BUFFER = 50;
+export const DEFAULT_GRID_CLIENT_PURGE_CLOSED_ROW_NODES = false;
+export const DEFAULT_GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING = false;
+
+export abstract class DataCubeEngine {
+  gridClientLicense?: string | undefined;
+  viewTaskRunner?:
+    | ((task: (view: DataCubeViewState) => void) => void)
+    | undefined;
+
+  readonly filterOperations = [
+    new DataCubeQueryFilterOperation__LessThan(),
+    new DataCubeQueryFilterOperation__LessThanOrEqual(),
+    new DataCubeQueryFilterOperation__Equal(),
+    new DataCubeQueryFilterOperation__NotEqual(),
+    new DataCubeQueryFilterOperation__GreaterThanOrEqual(),
+    new DataCubeQueryFilterOperation__GreaterThan(),
+
+    new DataCubeQueryFilterOperation__IsNull(),
+    new DataCubeQueryFilterOperation__IsNotNull(),
+
+    new DataCubeQueryFilterOperation__EqualCaseInsensitive(),
+    new DataCubeQueryFilterOperation__NotEqualCaseInsensitive(),
+    new DataCubeQueryFilterOperation__Contain(),
+    new DataCubeQueryFilterOperation__ContainCaseInsensitive(),
+    new DataCubeQueryFilterOperation__NotContain(),
+    new DataCubeQueryFilterOperation__StartWith(),
+    new DataCubeQueryFilterOperation__StartWithCaseInsensitive(),
+    new DataCubeQueryFilterOperation__NotStartWith(),
+    new DataCubeQueryFilterOperation__EndWith(),
+    new DataCubeQueryFilterOperation__EndWithCaseInsensitive(),
+    new DataCubeQueryFilterOperation__NotEndWith(),
+
+    new DataCubeQueryFilterOperation__LessThanColumn(),
+    new DataCubeQueryFilterOperation__LessThanOrEqualColumn(),
+    new DataCubeQueryFilterOperation__EqualColumn(),
+    new DataCubeQueryFilterOperation__NotEqualColumn(),
+    new DataCubeQueryFilterOperation__EqualCaseInsensitiveColumn(),
+    new DataCubeQueryFilterOperation__NotEqualCaseInsensitiveColumn(),
+    new DataCubeQueryFilterOperation__GreaterThanColumn(),
+    new DataCubeQueryFilterOperation__GreaterThanOrEqualColumn(),
+  ];
+  readonly aggregateOperations = [
+    new DataCubeQueryAggregateOperation__Sum(),
+    new DataCubeQueryAggregateOperation__Average(),
+    new DataCubeQueryAggregateOperation__Count(),
+    new DataCubeQueryAggregateOperation__Min(),
+    new DataCubeQueryAggregateOperation__Max(),
+    new DataCubeQueryAggregateOperation__UniqueValue(),
+    new DataCubeQueryAggregateOperation__First(),
+    new DataCubeQueryAggregateOperation__Last(),
+    new DataCubeQueryAggregateOperation__VariancePopulation(),
+    new DataCubeQueryAggregateOperation__VarianceSample(),
+    new DataCubeQueryAggregateOperation__StdDevPopulation(),
+    new DataCubeQueryAggregateOperation__StdDevSample(),
+    new DataCubeQueryAggregateOperation__JoinStrings(),
+  ];
+
+  enableDebugMode = DEFAULT_ENABLE_DEBUG_MODE;
+  enableEngineDebugMode = DEFAULT_ENABLE_ENGINE_DEBUG_MODE;
+
+  gridClientRowBuffer = DEFAULT_GRID_CLIENT_ROW_BUFFER;
+  gridClientPurgeClosedRowNodes = DEFAULT_GRID_CLIENT_PURGE_CLOSED_ROW_NODES;
+  gridClientSuppressLargeDatasetWarning =
+    DEFAULT_GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING;
+
+  getFilterOperation(value: string) {
+    return getFilterOperation(value, this.filterOperations);
+  }
+
+  getAggregateOperation(value: string) {
+    return getAggregateOperation(value, this.aggregateOperations);
+  }
+
+  setEnableDebugMode(value: boolean) {
+    this.enableDebugMode = value;
+  }
+
+  setEnableEngineDebugMode(value: boolean) {
+    this.enableEngineDebugMode = value;
+  }
+  setGridClientRowBuffer(value: number) {
+    this.gridClientRowBuffer = value;
+    this.propagateGridOptionUpdates();
+  }
+
+  setGridClientPurgeClosedRowNodes(value: boolean) {
+    this.gridClientPurgeClosedRowNodes = value;
+    this.propagateGridOptionUpdates();
+  }
+
+  setGridClientSuppressLargeDatasetWarning(value: boolean) {
+    this.gridClientSuppressLargeDatasetWarning = value;
+  }
+
+  async initialize(): Promise<void> {
+    const info = await this.getInfrastructureInfo();
+    if (info.gridClientLicense) {
+      this.gridClientLicense = info.gridClientLicense;
+      LicenseManager.setLicenseKey(info.gridClientLicense);
+    }
+
+    await configureCodeEditor(DataCubeFont.ROBOTO_MONO, (error) => {
+      throw error;
+    });
+    setupPureLanguageService({});
+  }
+
+  private propagateGridOptionUpdates() {
+    this.viewTaskRunner?.((view) => {
+      view.grid.client.updateGridOptions({
+        rowBuffer: this.gridClientRowBuffer,
+        purgeClosedRowNodes: this.gridClientPurgeClosedRowNodes,
+      });
+    });
+  }
+
+  refreshFailedDataFetches() {
+    this.viewTaskRunner?.((view) => {
+      view.grid.client.retryServerSideLoads();
+    });
+  }
+
+  abstract getInfrastructureInfo(): Promise<DataCubeInfrastructureInfo>;
+  abstract getQueryTypeahead(
+    code: string,
+    query: V1_ValueSpecification,
+  ): Promise<CompletionItem[]>;
+
+  abstract parseQuery(
+    code: string,
+    returnSourceInformation?: boolean,
+  ): Promise<V1_ValueSpecification>;
+
+  abstract getBaseQuery(): Promise<DataCubeGetBaseQueryResult>;
+
+  abstract getQueryRelationType(
+    query: V1_ValueSpecification,
+  ): Promise<RelationType>;
+
+  abstract getQueryCodeRelationReturnType(
+    code: string,
+    baseQuery: V1_ValueSpecification,
+  ): Promise<RelationType>;
+
+  abstract executeQuery(query: V1_Lambda): Promise<{
+    result: TDSExecutionResult;
+    executedQuery: string;
+    executedSQL: string;
+  }>;
+}

package/src/stores/engine/DataCubeLayoutManagerState.ts

@@ -0,0 +1,184 @@
+/**
+ * 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 { uuid } from '@finos/legend-shared';
+import {
+  action,
+  computed,
+  makeObservable,
+  observable,
+  runInAction,
+} from 'mobx';
+
+export type WindowConfiguration = {
+  x?: number | undefined;
+  y?: number | undefined;
+  width?: number | undefined;
+  height?: number | undefined;
+  minWidth?: number | undefined;
+  minHeight?: number | undefined;
+  center?: boolean | undefined;
+};
+
+export class LayoutConfiguration {
+  title: string;
+  readonly contentRenderer: (config: LayoutConfiguration) => React.ReactNode;
+  window: WindowConfiguration = {};
+
+  constructor(
+    title: string,
+    contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+  ) {
+    this.contentRenderer = contentRenderer;
+    this.title = title;
+  }
+}
+
+export class WindowState {
+  readonly uuid = uuid();
+  readonly configuration: LayoutConfiguration;
+  readonly onClose?: (() => void) | undefined;
+
+  constructor(
+    configuration: LayoutConfiguration,
+    onClose?: (() => void) | undefined,
+  ) {
+    this.configuration = configuration;
+    this.onClose = onClose;
+  }
+}
+
+export const WINDOW_DEFAULT_OFFSET = 50;
+export const WINDOW_DEFAULT_WIDTH = 800;
+export const WINDOW_DEFAULT_HEIGHT = 600;
+export const WINDOW_DEFAULT_MIN_WIDTH = 300;
+export const WINDOW_DEFAULT_MIN_HEIGHT = 300;
+
+export const DEFAULT_TOOL_PANEL_WINDOW_CONFIG: WindowConfiguration = {
+  width: WINDOW_DEFAULT_WIDTH,
+  height: WINDOW_DEFAULT_HEIGHT,
+  minWidth: WINDOW_DEFAULT_MIN_WIDTH,
+  minHeight: WINDOW_DEFAULT_MIN_HEIGHT,
+  center: true,
+};
+
+export const DEFAULT_SMALL_ALERT_WINDOW_CONFIG: WindowConfiguration = {
+  width: 500,
+  height: 200,
+  minWidth: 200,
+  minHeight: 80,
+  center: true,
+};
+
+export const DEFAULT_LARGE_ALERT_WINDOW_CONFIG: WindowConfiguration = {
+  width: 600,
+  height: 200,
+  minWidth: 300,
+  minHeight: 150,
+  center: true,
+};
+
+export class DisplayState {
+  private readonly layoutManagerState: LayoutManagerState;
+  readonly configuration: LayoutConfiguration;
+  window?: WindowState | undefined;
+
+  constructor(
+    layoutManagerState: LayoutManagerState,
+    title: string,
+    contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+  ) {
+    makeObservable(this, {
+      window: observable,
+      isOpen: computed,
+      open: action,
+      close: action,
+    });
+
+    this.layoutManagerState = layoutManagerState;
+    this.configuration = new LayoutConfiguration(title, contentRenderer);
+    this.configuration.window = DEFAULT_TOOL_PANEL_WINDOW_CONFIG;
+  }
+
+  get isOpen() {
+    return Boolean(this.window);
+  }
+
+  open() {
+    if (this.window) {
+      this.layoutManagerState.bringWindowFront(this.window);
+    } else {
+      this.window = new WindowState(this.configuration, () =>
+        runInAction(() => {
+          this.window = undefined;
+        }),
+      );
+      this.layoutManagerState.newWindow(this.window);
+    }
+  }
+
+  close() {
+    if (this.window) {
+      this.layoutManagerState.closeWindow(this.window);
+      this.window = undefined;
+    }
+  }
+}
+
+export class LayoutManagerState {
+  windows: WindowState[] = [];
+
+  constructor() {
+    makeObservable(this, {
+      windows: observable,
+      newWindow: action,
+      bringWindowFront: action,
+      closeWindow: action,
+    });
+  }
+
+  newDisplay(
+    title: string,
+    contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+    windowConfiguration?: WindowConfiguration | undefined,
+  ): DisplayState {
+    const display = new DisplayState(this, title, contentRenderer);
+    if (windowConfiguration) {
+      display.configuration.window = windowConfiguration;
+    }
+    return display;
+  }
+
+  newWindow(window: WindowState) {
+    this.windows.push(window);
+  }
+
+  bringWindowFront(window: WindowState) {
+    const matchingWindow = this.windows.find((w) => w.uuid === window.uuid);
+    if (matchingWindow) {
+      this.windows = this.windows.filter((w) => w.uuid !== window.uuid);
+      this.windows.push(window);
+    }
+  }
+
+  closeWindow(window: WindowState) {
+    const matchingWindow = this.windows.find((w) => w.uuid === window.uuid);
+    if (matchingWindow) {
+      this.windows = this.windows.filter((w) => w.uuid !== window.uuid);
+      window.onClose?.();
+    }
+  }
+}

package/src/stores/engine/DataCubeQuery.ts

@@ -0,0 +1,130 @@
+/**
+ * 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 {
+  SerializationFactory,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  optional,
+  primitive,
+  raw,
+  serialize,
+} from 'serializr';
+
+export abstract class DataCubeQuerySource {
+  columns: DataCubeQueryColumn[] = [];
+  query!: string;
+  runtime!: string;
+  mapping?: string | undefined;
+}
+
+export class DataCubeQueryColumn {
+  name!: string;
+  type!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeQueryColumn, {
+      name: primitive(),
+      type: primitive(),
+    }),
+  );
+}
+
+enum DataCubeQuerySourceType {
+  REPL_EXECUTED_QUERY = 'REPLExecutedQuery',
+}
+
+export class DataCubeQuerySourceREPLExecutedQuery extends DataCubeQuerySource {
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeQuerySourceREPLExecutedQuery, {
+      _type: usingConstantValueSchema(
+        DataCubeQuerySourceType.REPL_EXECUTED_QUERY,
+      ),
+      columns: list(usingModelSchema(DataCubeQueryColumn.serialization.schema)),
+      mapping: optional(primitive()),
+      query: primitive(),
+      runtime: primitive(),
+    }),
+  );
+}
+
+function deserializeQuerySource(
+  json: PlainObject<DataCubeQuerySource>,
+): DataCubeQuerySource {
+  switch (json._type) {
+    case DataCubeQuerySourceType.REPL_EXECUTED_QUERY:
+      return deserialize(
+        DataCubeQuerySourceREPLExecutedQuery.serialization.schema,
+        json,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize data cube query source of type '${json._type}'`,
+      );
+  }
+}
+
+function serializeQuerySource(
+  object: DataCubeQuerySource,
+): PlainObject<DataCubeQuerySource> {
+  if (object instanceof DataCubeQuerySourceREPLExecutedQuery) {
+    return serialize(
+      DataCubeQuerySourceREPLExecutedQuery.serialization.schema,
+      object,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize data cube query source`,
+    object,
+  );
+}
+
+export class DataCubeQuery {
+  name!: string;
+  query!: string;
+  partialQuery!: string;
+  source!: DataCubeQuerySource;
+  configuration?: PlainObject | undefined;
+
+  constructor(
+    name: string,
+    query: string,
+    configuration?: PlainObject | undefined,
+  ) {
+    this.name = name;
+    this.query = query;
+    this.configuration = configuration;
+  }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeQuery, {
+      /** TODO: @datacube roundtrip - populate this once we know the shape better */
+      configuration: raw(),
+      name: primitive(),
+      partialQuery: primitive(),
+      query: primitive(),
+      source: custom(serializeQuerySource, deserializeQuerySource),
+    }),
+  );
+}