@finos/legend-application-repl 0.0.21 → 0.0.23

package/src/stores/dataCube/core/DataCubeQuerySnapshot.ts

@@ -0,0 +1,201 @@
+/**
+ * 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_Lambda, V1_ValueSpecification } from '@finos/legend-graph';
+import type { DataCubeConfiguration } from '../../../server/models/DataCubeQuery.js';
+import { uuid, type PlainObject, type Writable } from '@finos/legend-shared';
+import type {
+  DATA_CUBE_AGGREGATE_FUNCTION,
+  DATA_CUBE_COLUMN_SORT_DIRECTION,
+} from '../DataCubeMetaModelConst.js';
+
+// export enum FILTER_OPERATION {
+//   EQUALS = 'equal',
+//   NOT_EQUAL = 'notEqual',
+//   GREATER_THAN = 'greaterThan',
+//   GREATER_THAN_OR_EQUAL = 'greaterThanOrEqual',
+//   LESS_THAN = 'lessThan',
+//   LESS_THAN_OR_EQUAL = 'lessThanOrEqual',
+//   BLANK = 'isEmpty',
+//   NOT_BLANK = 'isNotEmpty',
+//   CONTAINS = 'contains',
+//   NOT_CONTAINS = 'notContains',
+//   STARTS_WITH = 'startsWith',
+//   ENDS_WITH = 'endsWith',
+// }
+
+// export enum FILTER_GROUP {
+//   AND = 'and',
+//   OR = 'or',
+// }
+
+// export enum FILTER_TYPE {
+//   TEXT = 'text',
+//   NUMBER = 'number',
+// }
+
+// export class TDSFilterCondition {
+//   operation!: TDS_FILTER_OPERATION;
+//   value!: unknown;
+
+//   constructor(operation: TDS_FILTER_OPERATION, value: unknown) {
+//     this.operation = operation;
+//     this.value = value;
+//   }
+
+//   static readonly serialization = new SerializationFactory(
+//     createModelSchema(TDSFilterCondition, {
+//       operation: primitive(),
+//       value: primitive(),
+//     }),
+//   );
+// }
+
+// export class TDSFilter {
+//   column!: string;
+//   columnType!: PRIMITIVE_TYPE;
+//   conditions!: TDSFilterCondition[];
+//   groupOperation!: TDS_FILTER_GROUP;
+
+//   constructor(
+//     column: string,
+//     columnType: PRIMITIVE_TYPE,
+//     conditions: TDSFilterCondition[],
+//     groupOperation: TDS_FILTER_GROUP,
+//   ) {
+//     this.column = column;
+//     this.columnType = columnType;
+//     this.conditions = conditions;
+//     this.groupOperation = groupOperation;
+//   }
+
+//   static readonly serialization = new SerializationFactory(
+//     createModelSchema(TDSFilter, {
+//       column: primitive(),
+//       columnType: primitive(),
+//       conditions: list(
+//         usingModelSchema(TDSFilterCondition.serialization.schema),
+//       ),
+//       groupOperation: primitive(),
+//     }),
+//   );
+// }
+
+export type DataCubeQueryFilter = {
+  // TODO: @akphi
+};
+
+export enum DataCubeQuerySnapshotColumnOrigin {
+  SOURCE,
+  LEAF_EXTENDED,
+  RENAME,
+  GROUP_BY,
+  SELECT,
+  PIVOT,
+  GROUP_EXTENDED,
+}
+
+export type DataCubeQuerySnapshotColumn = {
+  name: string;
+  type: string;
+};
+
+export type DataCubeQuerySnapshotColumnWithOrigin =
+  DataCubeQuerySnapshotColumn & {
+    origin: DataCubeQuerySnapshotColumnOrigin;
+  };
+
+export type DataCubeQuerySnapshotExtendedColumn =
+  DataCubeQuerySnapshotColumn & {
+    lambda: PlainObject<V1_Lambda>;
+    code: string;
+  };
+
+export type DataCubeQuerySnapshotRenamedColumn = DataCubeQuerySnapshotColumn & {
+  oldName: string;
+};
+
+export type DataCubeQuerySnapshotSortColumn = DataCubeQuerySnapshotColumn & {
+  direction: DATA_CUBE_COLUMN_SORT_DIRECTION;
+};
+
+export type DataCubeQuerySnapshotAggregateColumn =
+  DataCubeQuerySnapshotColumn & {
+    function: DATA_CUBE_AGGREGATE_FUNCTION;
+  };
+
+export type DataCubeQuerySnapshot = {
+  readonly uuid: string;
+  name: string;
+  runtime: string;
+  sourceQuery: PlainObject<V1_ValueSpecification>;
+  configuration: DataCubeConfiguration;
+
+  originalColumns: DataCubeQuerySnapshotColumn[];
+  leafExtendedColumns: DataCubeQuerySnapshotExtendedColumn[];
+  filter?: DataCubeQueryFilter | undefined;
+  renamedColumns: DataCubeQuerySnapshotRenamedColumn[];
+  groupByColumns: DataCubeQuerySnapshotColumn[];
+  groupByAggColumns: DataCubeQuerySnapshotAggregateColumn[];
+  selectedColumns: DataCubeQuerySnapshotColumn[];
+  pivotColumns: DataCubeQuerySnapshotColumn[];
+  pivotAggColumns: DataCubeQuerySnapshotAggregateColumn[];
+  castColumns: DataCubeQuerySnapshotColumn[];
+  groupExtendedColumns: DataCubeQuerySnapshotExtendedColumn[];
+  sortColumns: DataCubeQuerySnapshotSortColumn[];
+  limit: number | undefined;
+  columns: DataCubeQuerySnapshotColumnWithOrigin[];
+};
+
+// ------------------------------------- UTILITIES -------------------------------------
+
+export function createSnapshot(
+  name: string,
+  runtime: string,
+  sourceQuery: PlainObject<V1_ValueSpecification>,
+  configuration: DataCubeConfiguration,
+): DataCubeQuerySnapshot {
+  return {
+    uuid: uuid(),
+    name,
+    runtime,
+    sourceQuery,
+    configuration,
+
+    originalColumns: [],
+    leafExtendedColumns: [],
+    filter: undefined,
+    renamedColumns: [],
+    groupByColumns: [],
+    groupByAggColumns: [],
+    selectedColumns: [],
+    pivotColumns: [],
+    pivotAggColumns: [],
+    castColumns: [],
+    groupExtendedColumns: [],
+    sortColumns: [],
+    limit: undefined,
+    columns: [],
+  };
+}
+
+export function cloneSnapshot(
+  snapshot: DataCubeQuerySnapshot,
+): DataCubeQuerySnapshot {
+  const clone = JSON.parse(JSON.stringify(snapshot)) as DataCubeQuerySnapshot;
+  (clone as Writable<DataCubeQuerySnapshot>).uuid = uuid();
+  return clone;
+}

package/src/stores/dataCube/core/DataCubeQuerySnapshotManager.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 { APPLICATION_EVENT } from '@finos/legend-application';
+import type { DataCubeState } from '../DataCubeState.js';
+import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
+import type { DataCubeQuerySnapshotSubscriber } from './DataCubeQuerySnapshotSubscriber.js';
+import {
+  LogEvent,
+  assertErrorThrown,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+
+// TODO: use this when we implement undo/redo
+// const DATA_CUBE_MAX_SNAPSHOT_COUNT = 100;
+
+export class DataCubeQuerySnapshotManager {
+  private readonly dataCubeState: DataCubeState;
+  private readonly subscribers: DataCubeQuerySnapshotSubscriber[] = [];
+  private readonly snapshots: DataCubeQuerySnapshot[] = [];
+
+  constructor(dataCubeState: DataCubeState) {
+    this.dataCubeState = dataCubeState;
+  }
+
+  get currentSnapshot(): DataCubeQuerySnapshot {
+    return guaranteeNonNullable(this.snapshots[this.snapshots.length - 1]);
+  }
+
+  registerSubscriber(subscriber: DataCubeQuerySnapshotSubscriber): void {
+    this.subscribers.push(subscriber);
+  }
+
+  broadcastSnapshot(snapshot: DataCubeQuerySnapshot): void {
+    this.snapshots.push(snapshot);
+    this.subscribers.forEach((subscriber) => {
+      const currentSnapshot = subscriber.getLatestSnapshot();
+      if (currentSnapshot?.uuid !== snapshot.uuid) {
+        subscriber.receiveSnapshot(snapshot).catch((error: unknown) => {
+          assertErrorThrown(error);
+          this.dataCubeState.applicationStore.logService.error(
+            LogEvent.create(
+              APPLICATION_EVENT.ILLEGAL_APPLICATION_STATE_OCCURRED,
+            ),
+            `Error ocurred when subscribers receive and apply new snapshot should be handled gracefully`,
+            error,
+          );
+        });
+      }
+    });
+  }
+
+  // TODO: replace snapshot (for minor modifications such as adjusting the cast columns)
+}

package/src/stores/dataCube/core/DataCubeQuerySnapshotSubscriber.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
+import type { DataCubeQuerySnapshotManager } from './DataCubeQuerySnapshotManager.js';
+
+export abstract class DataCubeQuerySnapshotSubscriber {
+  readonly manager: DataCubeQuerySnapshotManager;
+  private latestSnapshot: DataCubeQuerySnapshot | undefined;
+
+  constructor(snapshotManager: DataCubeQuerySnapshotManager) {
+    this.manager = snapshotManager;
+  }
+
+  abstract applySnapshot(snapshot: DataCubeQuerySnapshot): Promise<void>;
+
+  async receiveSnapshot(snapshot: DataCubeQuerySnapshot): Promise<void> {
+    this.latestSnapshot = snapshot;
+    await this.applySnapshot(snapshot);
+  }
+
+  publishSnapshot(snapshot: DataCubeQuerySnapshot): void {
+    this.latestSnapshot = snapshot;
+    this.manager.broadcastSnapshot(snapshot);
+  }
+
+  getLatestSnapshot(): DataCubeQuerySnapshot | undefined {
+    return this.latestSnapshot;
+  }
+}

package/src/stores/dataCube/editor/DataCubeEditorCodeState.ts

@@ -0,0 +1,166 @@
+/**
+ * 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 { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import type { DataCubeState } from '../DataCubeState.js';
+import {
+  HttpStatus,
+  NetworkClientError,
+  assertErrorThrown,
+  uuid,
+  type GeneratorFn,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  ParserError,
+  SourceInformation,
+  V1_ParserError,
+} from '@finos/legend-graph';
+
+export class DataCubeQueryEditorState {
+  uuid = uuid();
+  query: string;
+  parserError?: ParserError | undefined;
+
+  constructor(query: string) {
+    makeObservable(this, {
+      query: observable,
+      parserError: observable,
+      setQuery: action,
+      setParserError: action,
+    });
+
+    this.query = query;
+  }
+
+  setQuery(val: string): void {
+    this.query = val;
+  }
+
+  setParserError(parserError: ParserError | undefined): void {
+    // account for the lambda prefix offset in source information
+    if (parserError?.sourceInformation) {
+      parserError.sourceInformation = this.processSourceInformation(
+        parserError.sourceInformation,
+      );
+    }
+    this.parserError = parserError;
+  }
+
+  processSourceInformation(
+    sourceInformation: SourceInformation,
+  ): SourceInformation {
+    const { sourceId, startLine, startColumn, endLine, endColumn } =
+      sourceInformation;
+    const lineOffset = 0;
+    const columnOffset = 0;
+    return new SourceInformation(
+      sourceId,
+      startLine + lineOffset,
+      startColumn - (startLine === 1 ? columnOffset : 0),
+      endLine + lineOffset,
+      endColumn - (endLine === 1 ? columnOffset : 0),
+    );
+  }
+}
+
+export class DataCubeQueryCodeEditorState {
+  readonly dataCubeState!: DataCubeState;
+
+  queryEditorState!: DataCubeQueryEditorState;
+  currentSubQuery?: string | undefined;
+
+  constructor(dataCubeState: DataCubeState) {
+    makeObservable(this, {
+      currentSubQuery: observable,
+      queryEditorState: observable,
+      setCurrentSubQuery: action,
+      parseQuery: flow,
+    });
+
+    this.dataCubeState = dataCubeState;
+    this.queryEditorState = new DataCubeQueryEditorState('');
+  }
+
+  setCurrentSubQuery(val: string | undefined): void {
+    this.currentSubQuery = val;
+  }
+
+  *parseQuery(): GeneratorFn<void> {
+    try {
+      this.queryEditorState.setParserError(undefined);
+      yield flowResult(
+        this.dataCubeState.editorStore.client.parseQuery({
+          code: `|${this.queryEditorState.query}`,
+        }),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      if (
+        error instanceof NetworkClientError &&
+        error.response.status === HttpStatus.BAD_REQUEST
+      ) {
+        const protocol = V1_ParserError.serialization.fromJson(
+          error.payload as PlainObject<V1_ParserError>,
+        );
+        const parserError = new ParserError(protocol.message);
+        if (protocol.sourceInformation) {
+          parserError.sourceInformation = new SourceInformation(
+            protocol.sourceInformation.sourceId,
+            protocol.sourceInformation.startLine,
+            protocol.sourceInformation.startColumn,
+            protocol.sourceInformation.endLine,
+            protocol.sourceInformation.endColumn,
+          );
+        }
+        this.queryEditorState.setParserError(parserError);
+      }
+    }
+  }
+
+  // async getTypeaheadResults(
+  //   position: IPosition,
+  //   model: monacoEditorAPI.ITextModel,
+  // ): Promise<monacoLanguagesAPI.CompletionItem[]> {
+  //   try {
+  //     const textUntilPosition = model.getValueInRange({
+  //       startLineNumber: 1,
+  //       startColumn: 1,
+  //       endLineNumber: position.lineNumber,
+  //       endColumn: position.column,
+  //     });
+  //     const resultObj =
+  //       await this.editorStore.client.getTypeaheadResults(textUntilPosition);
+  //     const result = resultObj.map((res) =>
+  //       CompletionItem.serialization.fromJson(res),
+  //     );
+  //     const currentWord = model.getWordUntilPosition(position);
+  //     return result.map((res) => ({
+  //       label: res.display,
+  //       kind: monacoLanguagesAPI.CompletionItemKind.Text,
+  //       range: {
+  //         startLineNumber: position.lineNumber,
+  //         startColumn: currentWord.startColumn + 1,
+  //         endLineNumber: position.lineNumber,
+  //         endColumn: currentWord.endColumn + 1,
+  //       },
+  //       insertText: res.completion,
+  //     })) as monacoLanguagesAPI.CompletionItem[];
+  //   } catch (e) {
+  //     return [];
+  //   }
+  // }
+}

package/src/{components/grid/REPLGridServerResult.ts → stores/dataCube/editor/DataCubeEditorQuerySnapshotBuilder.ts}

@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 
-import { createModelSchema, primitive } from 'serializr';
-import { SerializationFactory } from '@finos/legend-shared';
+import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
 
-export class REPLGridServerResult {
-  currentQuery!: string;
-  result!: string;
+export interface DataCubeQueryEditorSubState {
+  /**
+   * Update the editor state based on the snapshot
+   */
+  applySnaphot(snapshot: DataCubeQuerySnapshot): void;
 
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(REPLGridServerResult, {
-      currentQuery: primitive(),
-      result: primitive(),
-    }),
-  );
+  /**
+   * Build and enrich the snapshot with data from the editor state
+   * @returns whether the snapshot should be updated or not
+   */
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ): boolean;
 }