@finos/legend-application-repl 1.0.31 → 1.0.33

package/src/stores/LegendREPLBaseStore.tsx

@@ -0,0 +1,135 @@
+/**
+ * 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 {
+  ActionState,
+  NetworkClient,
+  assertErrorThrown,
+  guaranteeNonNullable,
+  uuid,
+} from '@finos/legend-shared';
+import type { LegendREPLApplicationStore } from '../application/LegendREPLApplicationStore.js';
+import { LegendREPLServerClient } from './LegendREPLServerClient.js';
+import {
+  DataCubeConfiguration,
+  DataCubeQuery,
+  LayoutConfiguration,
+  WindowState,
+  type DataCubeState,
+} from '@finos/legend-data-cube';
+import { LegendREPLDataCubeSource } from './LegendREPLDataCubeSource.js';
+import { PersistentDataCubeQuery } from '@finos/legend-graph';
+import { LegendREPLPublishDataCubeAlert } from '../components/LegendREPLPublishDataCubeAlert.js';
+
+export class LegendREPLBaseStore {
+  readonly application: LegendREPLApplicationStore;
+  readonly client: LegendREPLServerClient;
+  readonly publishState = ActionState.create();
+
+  sourceQuery?: string | undefined;
+  currentUser?: string | undefined;
+  queryServerBaseUrl?: string | undefined;
+  hostedApplicationBaseUrl?: string | undefined;
+
+  constructor(application: LegendREPLApplicationStore) {
+    this.application = application;
+    this.client = new LegendREPLServerClient(
+      new NetworkClient({
+        baseUrl: application.config.useDynamicREPLServer
+          ? window.location.origin +
+            guaranteeNonNullable(application.config.baseAddress).replace(
+              '/repl/',
+              '',
+            )
+          : application.config.replUrl,
+      }),
+    );
+  }
+
+  async publishDataCube(dataCube: DataCubeState) {
+    const isPublishAllowed =
+      dataCube.view.source instanceof LegendREPLDataCubeSource &&
+      dataCube.view.source.isPersistenceSupported &&
+      // eslint-disable-next-line no-process-env
+      (process.env.NODE_ENV === 'development' || !dataCube.view.source.isLocal);
+
+    if (
+      !this.sourceQuery ||
+      !dataCube.view.isSourceProcessed ||
+      !this.queryServerBaseUrl ||
+      !isPublishAllowed
+    ) {
+      return;
+    }
+
+    this.publishState.inProgress();
+    const task = dataCube.view.newTask('Validate query');
+
+    try {
+      const query = new DataCubeQuery();
+      query.query = await dataCube.engine.getValueSpecificationCode(
+        dataCube.engine.generateInitialQuery(
+          dataCube.view.snapshotManager.currentSnapshot,
+        ),
+      );
+      query.source = {
+        // TODO: I can't think of a better name for now, but this form should be
+        // moved to the common module potentially
+        _type: 'basicQuery',
+        query: this.sourceQuery,
+        runtime: dataCube.view.source.runtime,
+        columns: dataCube.view.source.sourceColumns,
+        model: dataCube.view.source.model,
+      };
+      const newQuery = new PersistentDataCubeQuery();
+      newQuery.id = uuid();
+      newQuery.name = DataCubeConfiguration.serialization.fromJson(
+        dataCube.view.snapshotManager.currentSnapshot.data.configuration,
+      ).name;
+      newQuery.content = DataCubeQuery.serialization.toJson(query);
+      newQuery.owner = this.currentUser;
+      const publishedQuery = PersistentDataCubeQuery.serialization.fromJson(
+        await this.client.publishQuery(
+          PersistentDataCubeQuery.serialization.toJson(newQuery),
+          this.queryServerBaseUrl,
+        ),
+      );
+
+      const window = new WindowState(
+        new LayoutConfiguration('Publish Query', () => (
+          <LegendREPLPublishDataCubeAlert query={publishedQuery} />
+        )),
+      );
+      window.configuration.window = {
+        width: 420,
+        height: 150,
+        minWidth: 300,
+        minHeight: 100,
+        center: true,
+      };
+      dataCube.engine.layout.newWindow(window);
+    } catch (error) {
+      assertErrorThrown(error);
+      dataCube.view.engine.alertError(error, {
+        message: `Persistence Failure: Can't publish query.`,
+        text: `Error: ${error.message}`,
+      });
+    } finally {
+      dataCube.view.endTask(task);
+      this.publishState.complete();
+    }
+  }
+}

package/src/stores/LegendREPLDataCubeEngine.ts

@@ -15,7 +15,8 @@
  */
 
 import {
-  GetBaseQueryResult,
+  deserializeREPLQuerySource,
+  REPL_DATA_CUBE_SOURCE_TYPE,
   type LegendREPLServerClient,
 } from './LegendREPLServerClient.js';
 import {
@@ -24,8 +25,9 @@ import {
   _lambda,
   DataCubeEngine,
   DataCubeFunction,
-  type DataCubeAPI,
   type DataCubeSource,
+  type DataCubeAPI,
+  DataCubeQuery,
 } from '@finos/legend-data-cube';
 import {
   TDSExecutionResult,
@@ -36,12 +38,17 @@ import {
   V1_serializeValueSpecification,
   type V1_Lambda,
   type V1_ValueSpecification,
+  V1_buildEngineError,
+  V1_EngineError,
 } from '@finos/legend-graph';
 import {
+  assertErrorThrown,
   type DocumentationEntry,
   guaranteeType,
+  HttpStatus,
   isNonNullable,
   LogEvent,
+  NetworkClientError,
   type PlainObject,
 } from '@finos/legend-shared';
 import { LegendREPLDataCubeSource } from './LegendREPLDataCubeSource.js';
@@ -50,19 +57,19 @@ import {
   APPLICATION_EVENT,
   shouldDisplayVirtualAssistantDocumentationEntry,
 } from '@finos/legend-application';
+import type { LegendREPLBaseStore } from './LegendREPLBaseStore.js';
 
 export class LegendREPLDataCubeEngine extends DataCubeEngine {
   readonly application: LegendREPLApplicationStore;
+  readonly baseStore: LegendREPLBaseStore;
   readonly client: LegendREPLServerClient;
 
-  constructor(
-    application: LegendREPLApplicationStore,
-    client: LegendREPLServerClient,
-  ) {
+  constructor(baseStore: LegendREPLBaseStore) {
     super();
 
-    this.application = application;
-    this.client = client;
+    this.application = baseStore.application;
+    this.baseStore = baseStore;
+    this.client = baseStore.client;
   }
 
   blockNavigation(
@@ -92,37 +99,49 @@ export class LegendREPLDataCubeEngine extends DataCubeEngine {
 
   override async fetchConfiguration() {
     const info = await this.client.getInfrastructureInfo();
+    this.baseStore.currentUser = info.currentUser;
+    this.baseStore.queryServerBaseUrl = info.queryServerBaseUrl;
+    this.baseStore.hostedApplicationBaseUrl = info.hostedApplicationBaseUrl;
     return {
       gridClientLicense: info.gridClientLicense,
     };
   }
 
-  override async getInitialInput() {
-    const baseQuery = GetBaseQueryResult.serialization.fromJson(
+  async getBaseQuery() {
+    return DataCubeQuery.serialization.fromJson(
       await this.client.getBaseQuery(),
     );
+  }
+
+  async processQuerySource(value: PlainObject) {
+    const _source = deserializeREPLQuerySource(value);
+    this.baseStore.sourceQuery = _source.query;
+    if (value._type !== REPL_DATA_CUBE_SOURCE_TYPE) {
+      throw new Error(
+        `Can't process query source of type '${value._type}'. Only type '${REPL_DATA_CUBE_SOURCE_TYPE}' is supported.`,
+      );
+    }
+
     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.query = await this.parseValueSpecification(_source.query, false);
     source.sourceColumns = (
       await this.getQueryRelationType(_lambda([], [source.query]), source)
     ).columns;
+    source.runtime = _source.runtime;
 
-    return {
-      query: baseQuery.query,
-      source,
-    };
+    source.mapping = _source.mapping;
+    source.timestamp = _source.timestamp;
+    source.model = _source.model;
+    source.isLocal = _source.isLocal;
+    source.isPersistenceSupported = _source.isPersistenceSupported;
+
+    return source;
   }
 
   async parseValueSpecification(
     code: string,
     returnSourceInformation?: boolean,
-  ): Promise<V1_ValueSpecification> {
+  ) {
     return V1_deserializeValueSpecification(
       await this.client.parseValueSpecification({
         code,
@@ -164,10 +183,25 @@ export class LegendREPLDataCubeEngine extends DataCubeEngine {
     baseQuery: V1_ValueSpecification,
     source: DataCubeSource,
   ) {
-    return this.client.getQueryCodeRelationReturnType({
-      code,
-      baseQuery: V1_serializeValueSpecification(baseQuery, []),
-    });
+    try {
+      return await this.client.getQueryCodeRelationReturnType({
+        code,
+        baseQuery: V1_serializeValueSpecification(baseQuery, []),
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      if (
+        error instanceof NetworkClientError &&
+        error.response.status === HttpStatus.BAD_REQUEST
+      ) {
+        throw V1_buildEngineError(
+          V1_EngineError.serialization.fromJson(
+            error.payload as PlainObject<V1_EngineError>,
+          ),
+        );
+      }
+      throw error;
+    }
   }
 
   async executeQuery(

package/src/stores/LegendREPLDataCubeSource.ts

@@ -15,9 +15,14 @@
  */
 
 import { DataCubeSource } from '@finos/legend-data-cube';
+import type { PlainObject } from '@finos/legend-shared';
 
 export class LegendREPLDataCubeSource extends DataCubeSource {
   runtime!: string;
+
   mapping?: string | undefined;
   timestamp!: number;
+  model?: PlainObject | undefined;
+  isLocal!: boolean;
+  isPersistenceSupported!: boolean;
 }

package/src/stores/LegendREPLServerClient.ts

@@ -15,29 +15,25 @@
  */
 
 import {
-  assertErrorThrown,
   ContentType,
   guaranteeNonNullable,
   HttpHeader,
-  HttpStatus,
-  NetworkClientError,
   SerializationFactory,
-  usingModelSchema,
+  usingConstantValueSchema,
   type NetworkClient,
   type PlainObject,
 } from '@finos/legend-shared';
 import {
-  DataCubeQuery,
+  type DataCubeQuery,
   type CompletionItem,
   type RelationType,
 } from '@finos/legend-data-cube';
 import {
-  V1_buildEngineError,
-  V1_EngineError,
+  type PersistentDataCubeQuery,
   type V1_Lambda,
   type V1_ValueSpecification,
 } from '@finos/legend-graph';
-import { createModelSchema, optional, primitive } from 'serializr';
+import { createModelSchema, optional, primitive, raw } from 'serializr';
 
 type GetValueSpecificationCodeInput = {
   value: PlainObject<V1_ValueSpecification>;
@@ -75,18 +71,32 @@ type ExecutionResult = {
 };
 
 type InfrastructureInfo = {
+  currentUser?: string | undefined;
   gridClientLicense?: string | undefined;
+  queryServerBaseUrl?: string | undefined;
+  hostedApplicationBaseUrl?: string | undefined;
 };
 
-class QuerySource {
+export const REPL_DATA_CUBE_SOURCE_TYPE = 'repl';
+
+class REPLBaseDataCubeQuerySource {
+  query!: string;
   runtime!: string;
+  model?: PlainObject | undefined;
+
   mapping?: string | undefined;
-  query!: string;
   timestamp!: number;
+  isLocal!: boolean;
+  isPersistenceSupported!: boolean;
+  // columns // we don't need this analytics, we will get this from the query directly
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(QuerySource, {
+    createModelSchema(REPLBaseDataCubeQuerySource, {
+      _type: usingConstantValueSchema(REPL_DATA_CUBE_SOURCE_TYPE),
+      isLocal: primitive(),
+      isPersistenceSupported: primitive(),
       mapping: optional(primitive()),
+      model: optional(raw()),
       query: primitive(),
       runtime: primitive(),
       timestamp: primitive(),
@@ -94,16 +104,10 @@ class QuerySource {
   );
 }
 
-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 function deserializeREPLQuerySource(
+  value: PlainObject<REPLBaseDataCubeQuerySource>,
+) {
+  return REPLBaseDataCubeQuerySource.serialization.fromJson(value);
 }
 
 export class LegendREPLServerClient {
@@ -154,7 +158,7 @@ export class LegendREPLServerClient {
     );
   }
 
-  async getBaseQuery(): Promise<PlainObject<GetBaseQueryResult>> {
+  async getBaseQuery(): Promise<PlainObject<DataCubeQuery>> {
     return this.networkClient.get(`${this.dataCube}/getBaseQuery`);
   }
 
@@ -170,25 +174,10 @@ export class LegendREPLServerClient {
   async getQueryCodeRelationReturnType(
     input: GetQueryCodeRelationReturnTypeInput,
   ): Promise<RelationType> {
-    try {
-      return this.networkClient.post(
-        `${this.dataCube}/getRelationReturnType/code`,
-        input,
-      );
-    } catch (error) {
-      assertErrorThrown(error);
-      if (
-        error instanceof NetworkClientError &&
-        error.response.status === HttpStatus.BAD_REQUEST
-      ) {
-        throw V1_buildEngineError(
-          V1_EngineError.serialization.fromJson(
-            error.payload as PlainObject<V1_EngineError>,
-          ),
-        );
-      }
-      throw error;
-    }
+    return this.networkClient.post(
+      `${this.dataCube}/getRelationReturnType/code`,
+      input,
+    );
   }
 
   async executeQuery(
@@ -196,4 +185,11 @@ export class LegendREPLServerClient {
   ): Promise<ExecutionResult> {
     return this.networkClient.post(`${this.dataCube}/executeQuery`, input);
   }
+
+  async publishQuery(
+    query: PlainObject<PersistentDataCubeQuery>,
+    queryStoreBaseUrl: string,
+  ): Promise<PlainObject<PersistentDataCubeQuery>> {
+    return this.networkClient.post(`${queryStoreBaseUrl}`, query);
+  }
 }

package/tsconfig.json

@@ -54,12 +54,17 @@
     "./src/__lib__/LegendREPLSetting.ts",
     "./src/application/LegendREPLApplicationConfig.ts",
     "./src/application/LegendREPLApplicationStore.ts",
+    "./src/application/LegendREPLNavigation.ts",
     "./src/stores/LegendREPLDataCubeEngine.ts",
     "./src/stores/LegendREPLDataCubeSource.ts",
     "./src/stores/LegendREPLServerClient.ts",
     "./src/index.tsx",
     "./src/application/LegendREPL.tsx",
-    "./src/components/LegendREPLApplication.tsx"
+    "./src/components/LegendREPLApplication.tsx",
+    "./src/components/LegendREPLDataCubeHeader.tsx",
+    "./src/components/LegendREPLFramworkProvider.tsx",
+    "./src/components/LegendREPLPublishDataCubeAlert.tsx",
+    "./src/stores/LegendREPLBaseStore.tsx"
   ],
   "include": [
     "src/**/*.ts",