@finos/legend-application-repl 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-application-repl",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Legend REPL Grid client application core",
   "keywords": [
     "legend",
@@ -43,17 +43,18 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@finos/legend-application": "16.0.3",
-    "@finos/legend-art": "7.1.62",
-    "@finos/legend-data-cube": "0.0.9",
-    "@finos/legend-graph": "31.10.38",
+    "@finos/legend-application": "16.0.4",
+    "@finos/legend-art": "7.1.63",
+    "@finos/legend-data-cube": "0.0.11",
+    "@finos/legend-graph": "31.10.40",
     "@finos/legend-shared": "10.0.57",
     "@types/react": "18.3.11",
     "@types/react-dom": "18.3.0",
     "mobx": "6.13.3",
     "mobx-react-lite": "4.0.7",
     "react": "18.3.1",
-    "react-dom": "18.3.1"
+    "react-dom": "18.3.1",
+    "serializr": "3.0.2"
   },
   "devDependencies": {
     "@finos/legend-dev-utils": "2.1.25",

package/src/components/LegendREPLApplication.tsx

@@ -22,14 +22,14 @@ import {
 import { observer } from 'mobx-react-lite';
 import { useEffect, useMemo } from 'react';
 import {
+  formatDate,
   guaranteeNonNullable,
   LogEvent,
   NetworkClient,
 } from '@finos/legend-shared';
 import { LegendREPLServerClient } from '../stores/LegendREPLServerClient.js';
-import { LegendREPLDataCubeApplicationEngine } from '../stores/LegendREPLDataCubeApplicationEngine.js';
 import { LegendREPLDataCubeEngine } from '../stores/LegendREPLDataCubeEngine.js';
-import { DataCube, DataCubeProvider } from '@finos/legend-data-cube';
+import { DataCube, DataCubeSettingKey } from '@finos/legend-data-cube';
 import {
   APPLICATION_EVENT,
   ApplicationFrameworkProvider,
@@ -38,53 +38,81 @@ import {
   type LegendApplicationPluginManager,
 } from '@finos/legend-application';
 import type { LegendREPLApplicationConfig } from '../application/LegendREPLApplicationConfig.js';
+import { LegendREPLDataCubeSource } from '../stores/LegendREPLDataCubeSource.js';
 
 const LegendREPLDataCube = observer(() => {
-  const applicationStore = useApplicationStore<
+  const application = useApplicationStore<
     LegendREPLApplicationConfig,
     LegendApplicationPluginManager<LegendApplicationPlugin>
   >();
-  const application = useMemo(
-    () => new LegendREPLDataCubeApplicationEngine(applicationStore),
-    [applicationStore],
-  );
-  const engine = new LegendREPLDataCubeEngine(
-    application,
-    new LegendREPLServerClient(
-      new NetworkClient({
-        baseUrl: applicationStore.config.useDynamicREPLServer
-          ? window.location.origin +
-            guaranteeNonNullable(applicationStore.config.baseAddress).replace(
-              '/repl/',
-              '',
-            )
-          : applicationStore.config.replUrl,
-      }),
-    ),
+  const config = application.config;
+  const engine = useMemo(
+    () =>
+      new LegendREPLDataCubeEngine(
+        application,
+        new LegendREPLServerClient(
+          new NetworkClient({
+            baseUrl: config.useDynamicREPLServer
+              ? window.location.origin +
+                guaranteeNonNullable(config.baseAddress).replace('/repl/', '')
+              : config.replUrl,
+          }),
+        ),
+      ),
+    [application, config],
   );
 
   useEffect(() => {
-    application.blockNavigation(
+    engine.blockNavigation(
       // Only block navigation in production
       // eslint-disable-next-line no-process-env
       [() => process.env.NODE_ENV === 'production'],
       undefined,
       () => {
-        application.logWarning(
+        engine.logWarning(
           LogEvent.create(APPLICATION_EVENT.NAVIGATION_BLOCKED),
           `Navigation from the application is blocked`,
         );
       },
     );
     return (): void => {
-      application.unblockNavigation();
+      engine.unblockNavigation();
     };
-  }, [application]);
+  }, [engine]);
 
   return (
-    <DataCubeProvider application={application} engine={engine}>
-      <DataCube />
-    </DataCubeProvider>
+    <DataCube
+      engine={engine}
+      options={{
+        onNameChanged(name, source) {
+          const timestamp =
+            source instanceof LegendREPLDataCubeSource
+              ? source.timestamp
+              : undefined;
+          application.layoutService.setWindowTitle(
+            `\u229E ${name}${timestamp ? ` - ${formatDate(new Date(timestamp), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
+          );
+        },
+        onSettingChanged(key, value) {
+          engine.persistSettingValue(key, value);
+        },
+
+        enableDebugMode: application.settingService.getBooleanValue(
+          DataCubeSettingKey.ENABLE_DEBUG_MODE,
+        ),
+        gridClientRowBuffer: application.settingService.getNumericValue(
+          DataCubeSettingKey.GRID_CLIENT_ROW_BUFFER,
+        ),
+        gridClientPurgeClosedRowNodes:
+          application.settingService.getBooleanValue(
+            DataCubeSettingKey.GRID_CLIENT_PURGE_CLOSED_ROW_NODES,
+          ),
+        gridClientSuppressLargeDatasetWarning:
+          application.settingService.getBooleanValue(
+            DataCubeSettingKey.GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING,
+          ),
+      }}
+    />
   );
 });
 

package/src/stores/LegendREPLDataCubeEngine.ts

@@ -14,20 +14,22 @@
  * limitations under the License.
  */
 
-import type { LegendREPLServerClient } from './LegendREPLServerClient.js';
 import {
+  GetBaseQueryResult,
+  type LegendREPLServerClient,
+} from './LegendREPLServerClient.js';
+import {
+  _elementPtr,
+  _function,
+  _lambda,
   DataCubeEngine,
-  DataCubeGetBaseQueryResult,
-  DEFAULT_ENABLE_DEBUG_MODE,
-  DEFAULT_GRID_CLIENT_PURGE_CLOSED_ROW_NODES,
-  DEFAULT_GRID_CLIENT_ROW_BUFFER,
-  DEFAULT_GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING,
-  type CompletionItem,
-  type DataCubeInfrastructureInfo,
-  type RelationType,
+  DataCubeFunction,
+  type DataCubeAPI,
+  type DataCubeSource,
 } from '@finos/legend-data-cube';
 import {
   TDSExecutionResult,
+  type V1_AppliedFunction,
   V1_buildExecutionResult,
   V1_deserializeValueSpecification,
   V1_serializeExecutionResult,
@@ -35,116 +37,123 @@ import {
   type V1_Lambda,
   type V1_ValueSpecification,
 } from '@finos/legend-graph';
-import { guaranteeType } from '@finos/legend-shared';
-import type { LegendREPLDataCubeApplicationEngine } from './LegendREPLDataCubeApplicationEngine.js';
-import { LEGEND_REPL_SETTING_KEY } from '../__lib__/LegendREPLSetting.js';
+import {
+  type DocumentationEntry,
+  guaranteeType,
+  isNonNullable,
+  LogEvent,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { LegendREPLDataCubeSource } from './LegendREPLDataCubeSource.js';
+import type { LegendREPLApplicationStore } from '../application/LegendREPLApplicationStore.js';
+import {
+  APPLICATION_EVENT,
+  shouldDisplayVirtualAssistantDocumentationEntry,
+} from '@finos/legend-application';
 
 export class LegendREPLDataCubeEngine extends DataCubeEngine {
-  readonly application: LegendREPLDataCubeApplicationEngine;
+  readonly application: LegendREPLApplicationStore;
   readonly client: LegendREPLServerClient;
 
   constructor(
-    application: LegendREPLDataCubeApplicationEngine,
+    application: LegendREPLApplicationStore,
     client: LegendREPLServerClient,
   ) {
     super();
 
     this.application = application;
     this.client = client;
-
-    this.enableDebugMode =
-      this.application.getPersistedBooleanValue(
-        LEGEND_REPL_SETTING_KEY.ENABLE_DEBUG_MODE,
-      ) ?? DEFAULT_ENABLE_DEBUG_MODE;
-    this.gridClientRowBuffer =
-      this.application.getPersistedNumericValue(
-        LEGEND_REPL_SETTING_KEY.GRID_CLIENT_ROW_BUFFER,
-      ) ?? DEFAULT_GRID_CLIENT_ROW_BUFFER;
-    this.gridClientPurgeClosedRowNodes =
-      this.application.getPersistedBooleanValue(
-        LEGEND_REPL_SETTING_KEY.GRID_CLIENT_PURGE_CLOSED_ROW_NODES,
-      ) ?? DEFAULT_GRID_CLIENT_PURGE_CLOSED_ROW_NODES;
-    this.gridClientSuppressLargeDatasetWarning =
-      this.application.getPersistedBooleanValue(
-        LEGEND_REPL_SETTING_KEY.GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING,
-      ) ?? DEFAULT_GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING;
-  }
-
-  override setEnableDebugMode(value: boolean) {
-    super.setEnableDebugMode(value);
-    this.application.persistValue(
-      LEGEND_REPL_SETTING_KEY.ENABLE_DEBUG_MODE,
-      value,
-    );
   }
 
-  override setGridClientRowBuffer(value: number) {
-    super.setGridClientRowBuffer(value);
-    this.application.persistValue(
-      LEGEND_REPL_SETTING_KEY.GRID_CLIENT_ROW_BUFFER,
-      value,
+  blockNavigation(
+    blockCheckers: (() => boolean)[],
+    onBlock?: ((onProceed: () => void) => void) | undefined,
+    onNativePlatformNavigationBlock?: (() => void) | undefined,
+  ) {
+    this.application.navigationService.navigator.blockNavigation(
+      blockCheckers,
+      onBlock,
+      onNativePlatformNavigationBlock,
     );
   }
 
-  override setGridClientPurgeClosedRowNodes(value: boolean) {
-    super.setGridClientPurgeClosedRowNodes(value);
-    this.application.persistValue(
-      LEGEND_REPL_SETTING_KEY.GRID_CLIENT_PURGE_CLOSED_ROW_NODES,
-      value,
-    );
+  unblockNavigation() {
+    this.application.navigationService.navigator.unblockNavigation();
   }
 
-  override setGridClientSuppressLargeDatasetWarning(value: boolean) {
-    super.setGridClientSuppressLargeDatasetWarning(value);
-    this.application.persistValue(
-      LEGEND_REPL_SETTING_KEY.GRID_CLIENT_SUPPRESS_LARGE_DATASET_WARNING,
-      value,
-    );
+  persistSettingValue(
+    key: string,
+    value: string | number | boolean | object | undefined,
+  ): void {
+    this.application.settingService.persistValue(key, value);
   }
 
-  async getInfrastructureInfo(): Promise<DataCubeInfrastructureInfo> {
-    return this.client.getInfrastructureInfo();
+  // ---------------------------------- IMPLEMENTATION ----------------------------------
+
+  override async fetchConfiguration() {
+    const info = await this.client.getInfrastructureInfo();
+    return {
+      gridClientLicense: info.gridClientLicense,
+    };
   }
 
-  async getQueryTypeahead(
-    code: string,
-    query: V1_ValueSpecification,
-  ): Promise<CompletionItem[]> {
-    return this.client.getQueryTypeahead({
-      code,
-      baseQuery: V1_serializeValueSpecification(query, []),
-    });
+  override async getInitialInput() {
+    const baseQuery = GetBaseQueryResult.serialization.fromJson(
+      await this.client.getBaseQuery(),
+    );
+    const source = new LegendREPLDataCubeSource();
+    source.mapping = baseQuery.source.mapping;
+    source.query = await this.parseValueSpecification(
+      baseQuery.source.query,
+      false,
+    );
+    source.runtime = baseQuery.source.runtime;
+    source.timestamp = baseQuery.source.timestamp;
+    source.sourceColumns = (
+      await this.getQueryRelationType(_lambda([], [source.query]), source)
+    ).columns;
+
+    return {
+      query: baseQuery.query,
+      source,
+    };
   }
 
-  async parseQuery(
+  async parseValueSpecification(
     code: string,
     returnSourceInformation?: boolean,
   ): Promise<V1_ValueSpecification> {
     return V1_deserializeValueSpecification(
-      await this.client.parseQuery({ code, returnSourceInformation }),
+      await this.client.parseValueSpecification({
+        code,
+        returnSourceInformation,
+      }),
       [],
     );
   }
 
-  override getQueryCode(
-    query: V1_ValueSpecification,
+  override getValueSpecificationCode(
+    value: V1_ValueSpecification,
     pretty?: boolean,
-  ): Promise<string> {
-    return this.client.getQueryCode({
-      query: V1_serializeValueSpecification(query, []),
+  ) {
+    return this.client.getValueSpecificationCode({
+      value: V1_serializeValueSpecification(value, []),
       pretty,
     });
   }
 
-  async getBaseQuery(): Promise<DataCubeGetBaseQueryResult> {
-    return DataCubeGetBaseQueryResult.serialization.fromJson(
-      await this.client.getBaseQuery(),
-    );
+  async getQueryTypeahead(
+    code: string,
+    baseQuery: V1_Lambda,
+    source: DataCubeSource,
+  ) {
+    return this.client.getQueryTypeahead({
+      code,
+      baseQuery: V1_serializeValueSpecification(baseQuery, []),
+    });
   }
 
-  async getQueryRelationType(
-    query: V1_ValueSpecification,
-  ): Promise<RelationType> {
+  async getQueryRelationType(query: V1_Lambda, source: DataCubeSource) {
     return this.client.getQueryRelationReturnType({
       query: V1_serializeValueSpecification(query, []),
     });
@@ -153,21 +162,22 @@ export class LegendREPLDataCubeEngine extends DataCubeEngine {
   async getQueryCodeRelationReturnType(
     code: string,
     baseQuery: V1_ValueSpecification,
-  ): Promise<RelationType> {
+    source: DataCubeSource,
+  ) {
     return this.client.getQueryCodeRelationReturnType({
       code,
       baseQuery: V1_serializeValueSpecification(baseQuery, []),
     });
   }
 
-  async executeQuery(query: V1_Lambda): Promise<{
-    result: TDSExecutionResult;
-    executedQuery: string;
-    executedSQL: string;
-  }> {
+  async executeQuery(
+    query: V1_Lambda,
+    source: DataCubeSource,
+    api: DataCubeAPI,
+  ) {
     const result = await this.client.executeQuery({
       query: V1_serializeValueSpecification(query, []),
-      debug: this.enableDebugMode,
+      debug: api.getSettings().enableDebugMode,
     });
     return {
       result: guaranteeType(
@@ -180,4 +190,80 @@ export class LegendREPLDataCubeEngine extends DataCubeEngine {
       executedSQL: result.executedSQL,
     };
   }
+
+  override buildExecutionContext(
+    source: DataCubeSource,
+  ): V1_AppliedFunction | undefined {
+    if (source instanceof LegendREPLDataCubeSource) {
+      return _function(
+        DataCubeFunction.FROM,
+        [
+          source.mapping ? _elementPtr(source.mapping) : undefined,
+          _elementPtr(source.runtime),
+        ].filter(isNonNullable),
+      );
+    }
+    return undefined;
+  }
+
+  override getDocumentationURL(): string | undefined {
+    return this.application.documentationService.url;
+  }
+
+  override getDocumentationEntry(key: string) {
+    return this.application.documentationService.getDocEntry(key);
+  }
+
+  override shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
+    return shouldDisplayVirtualAssistantDocumentationEntry(entry);
+  }
+
+  override openLink(url: string) {
+    this.application.navigationService.navigator.visitAddress(url);
+  }
+
+  override sendTelemetry(event: string, data: PlainObject) {
+    this.application.telemetryService.logEvent(event, data);
+  }
+
+  override logDebug(message: string, ...data: unknown[]) {
+    this.application.logService.debug(
+      LogEvent.create(APPLICATION_EVENT.DEBUG),
+      message,
+      ...data,
+    );
+  }
+
+  override debugProcess(processName: string, ...data: [string, unknown][]) {
+    this.application.logService.debug(
+      LogEvent.create(APPLICATION_EVENT.DEBUG),
+      `\n------ START DEBUG PROCESS: ${processName} ------`,
+      ...data.flatMap(([key, value]) => [`\n[${key.toUpperCase()}]:`, value]),
+      `\n------- END DEBUG PROCESS: ${processName} -------\n\n`,
+    );
+  }
+
+  override logInfo(event: LogEvent, ...data: unknown[]) {
+    this.application.logService.info(event, ...data);
+  }
+
+  override logWarning(event: LogEvent, ...data: unknown[]) {
+    this.application.logService.warn(event, ...data);
+  }
+
+  override logError(event: LogEvent, ...data: unknown[]) {
+    this.application.logService.error(event, ...data);
+  }
+
+  override logUnhandledError(error: Error) {
+    this.application.logUnhandledError(error);
+  }
+
+  override logIllegalStateError(message: string, error?: Error) {
+    this.logError(
+      LogEvent.create(APPLICATION_EVENT.ILLEGAL_APPLICATION_STATE_OCCURRED),
+      message,
+      error,
+    );
+  }
 }

package/src/stores/LegendREPLDataCubeSource.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { DataCubeSource } from '@finos/legend-data-cube';
+
+export class LegendREPLDataCubeSource extends DataCubeSource {
+  runtime!: string;
+  mapping?: string | undefined;
+  timestamp!: number;
+}

package/src/stores/LegendREPLServerClient.ts

@@ -18,52 +18,86 @@ import {
   ContentType,
   guaranteeNonNullable,
   HttpHeader,
+  SerializationFactory,
+  usingModelSchema,
   type NetworkClient,
   type PlainObject,
 } from '@finos/legend-shared';
-import type {
-  CompletionItem,
-  RelationType,
-  DataCubeGetBaseQueryResult,
-  DataCubeInfrastructureInfo,
+import {
+  DataCubeQuery,
+  type CompletionItem,
+  type RelationType,
 } from '@finos/legend-data-cube';
 import type { V1_Lambda, V1_ValueSpecification } from '@finos/legend-graph';
+import { createModelSchema, optional, primitive } from 'serializr';
 
-type DataCubeGetQueryCodeInput = {
-  query: PlainObject<V1_ValueSpecification>;
+type GetValueSpecificationCodeInput = {
+  value: PlainObject<V1_ValueSpecification>;
   pretty?: boolean | undefined;
 };
 
-type DataCubeParseQueryInput = {
+type ParseValueSpecificationInput = {
   code: string;
   returnSourceInformation?: boolean | undefined;
 };
 
-type DataCubeQueryTypeaheadInput = {
+type QueryTypeaheadInput = {
   code: string;
-  baseQuery?: PlainObject<V1_ValueSpecification>;
+  baseQuery?: PlainObject<V1_Lambda>;
 };
 
-type DataCubeGetQueryRelationReturnTypeInput = {
+type GetQueryRelationReturnTypeInput = {
   query: PlainObject<V1_Lambda>;
 };
 
-type DataCubeGetQueryCodeRelationReturnTypeInput = {
+type GetQueryCodeRelationReturnTypeInput = {
   code: string;
   baseQuery?: PlainObject<V1_ValueSpecification>;
 };
 
-type DataCubeExecutionInput = {
+type ExecutionInput = {
   query: PlainObject<V1_Lambda>;
   debug?: boolean | undefined;
 };
 
-type DataCubeExecutionResult = {
+type ExecutionResult = {
   result: string;
   executedQuery: string;
   executedSQL: string;
 };
 
+type InfrastructureInfo = {
+  gridClientLicense?: string | undefined;
+};
+
+class QuerySource {
+  runtime!: string;
+  mapping?: string | undefined;
+  query!: string;
+  timestamp!: number;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(QuerySource, {
+      mapping: optional(primitive()),
+      query: primitive(),
+      runtime: primitive(),
+      timestamp: primitive(),
+    }),
+  );
+}
+
+export class GetBaseQueryResult {
+  query!: DataCubeQuery;
+  source!: QuerySource;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(GetBaseQueryResult, {
+      query: usingModelSchema(DataCubeQuery.serialization.schema),
+      source: usingModelSchema(QuerySource.serialization.schema),
+    }),
+  );
+}
+
 export class LegendREPLServerClient {
   private readonly networkClient: NetworkClient;
 
@@ -82,37 +116,42 @@ export class LegendREPLServerClient {
     return `${this.baseUrl}/api/dataCube`;
   }
 
-  async getInfrastructureInfo(): Promise<DataCubeInfrastructureInfo> {
+  async getInfrastructureInfo(): Promise<InfrastructureInfo> {
     return this.networkClient.get(`${this.dataCube}/infrastructureInfo`);
   }
 
   async getQueryTypeahead(
-    input: DataCubeQueryTypeaheadInput,
+    input: QueryTypeaheadInput,
   ): Promise<CompletionItem[]> {
     return this.networkClient.post(`${this.dataCube}/typeahead`, input);
   }
 
-  async parseQuery(
-    input: DataCubeParseQueryInput,
+  async parseValueSpecification(
+    input: ParseValueSpecificationInput,
   ): Promise<PlainObject<V1_ValueSpecification>> {
-    return this.networkClient.post(`${this.dataCube}/parseQuery`, input);
+    return this.networkClient.post(
+      `${this.dataCube}/parseValueSpecification`,
+      input,
+    );
   }
 
-  async getQueryCode(input: DataCubeGetQueryCodeInput): Promise<string> {
+  async getValueSpecificationCode(
+    input: GetValueSpecificationCodeInput,
+  ): Promise<string> {
     return this.networkClient.post(
-      `${this.dataCube}/getQueryCode`,
+      `${this.dataCube}/getValueSpecificationCode`,
       input,
       {},
       { [HttpHeader.ACCEPT]: ContentType.TEXT_PLAIN },
     );
   }
 
-  async getBaseQuery(): Promise<PlainObject<DataCubeGetBaseQueryResult>> {
+  async getBaseQuery(): Promise<PlainObject<GetBaseQueryResult>> {
     return this.networkClient.get(`${this.dataCube}/getBaseQuery`);
   }
 
   async getQueryRelationReturnType(
-    input: DataCubeGetQueryRelationReturnTypeInput,
+    input: GetQueryRelationReturnTypeInput,
   ): Promise<RelationType> {
     return this.networkClient.post(
       `${this.dataCube}/getRelationReturnType`,
@@ -121,7 +160,7 @@ export class LegendREPLServerClient {
   }
 
   async getQueryCodeRelationReturnType(
-    input: DataCubeGetQueryCodeRelationReturnTypeInput,
+    input: GetQueryCodeRelationReturnTypeInput,
   ): Promise<RelationType> {
     return this.networkClient.post(
       `${this.dataCube}/getRelationReturnType/code`,
@@ -130,8 +169,8 @@ export class LegendREPLServerClient {
   }
 
   async executeQuery(
-    input: PlainObject<DataCubeExecutionInput>,
-  ): Promise<DataCubeExecutionResult> {
+    input: PlainObject<ExecutionInput>,
+  ): Promise<ExecutionResult> {
     return this.networkClient.post(`${this.dataCube}/executeQuery`, input);
   }
 }