@finos/legend-application-query 5.0.0

package/src/graphManager/protocol/pure/v1/V1_QueryBuilder_PureGraphManagerExtension.ts

@@ -0,0 +1,296 @@
+/**
+ * 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 {
+  EngineRuntime,
+  GraphBuilderError,
+  MappingInclude,
+  V1_getIncludedMappingPath,
+  V1_GraphBuilderContextBuilder,
+  V1_Mapping,
+  V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
+  V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
+  V1_PureMultiExecution,
+  V1_Service,
+  V1_PackageableRuntime,
+  type V1_PackageableElement,
+  type PureModel,
+  V1_PureGraphManager,
+  PureClientVersion,
+  type AbstractPureGraphManager,
+  type V1_EngineRuntime,
+  CORE_PURE_PATH,
+  getAllIncludedMappings,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+import {
+  assertErrorThrown,
+  filterByType,
+  guaranteeNonEmptyString,
+  guaranteeType,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { MappingRuntimeCompatibilityAnalysisResult } from '../../../action/analytics/MappingRuntimeCompatibilityAnalysis.js';
+import { ServiceExecutionAnalysisResult } from '../../../action/analytics/ServiceExecutionAnalysis.js';
+import { QueryBuilder_PureGraphManagerExtension } from '../QueryBuilder_PureGraphManagerExtension.js';
+
+export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_PureGraphManagerExtension {
+  declare graphManager: V1_PureGraphManager;
+
+  constructor(graphManager: AbstractPureGraphManager) {
+    super(graphManager);
+    this.graphManager = guaranteeType(graphManager, V1_PureGraphManager);
+  }
+
+  getSupportedProtocolVersion(): string {
+    return PureClientVersion.V1_0_0;
+  }
+
+  // We could optimize this further by omitting parts of the entities we don't need
+  async buildGraphForCreateQuerySetup(
+    graph: PureModel,
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<void> {
+    try {
+      const graphBuilderInput = await this.graphManager.indexLightGraph(
+        graph,
+        entities,
+        dependencyEntities,
+        (entity: Entity): boolean =>
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_MAPPING_ELEMENT_PROTOCOL_TYPE ||
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
+      );
+      // handle mapping includes
+      const mappings = [
+        ...graph.ownMappings,
+        ...graph.dependencyManager.mappings,
+      ];
+      const v1Mappings = graphBuilderInput
+        .map((e) => e.data.elements.filter(filterByType(V1_Mapping)))
+        .flat();
+      const context = new V1_GraphBuilderContextBuilder(
+        graph,
+        graph,
+        this.graphManager.graphBuilderExtensions,
+        this.graphManager.log,
+      ).build();
+      // build include index for compatible runtime analysis
+      v1Mappings.forEach((element) => {
+        const mapping = mappings.find((e) => e.path === element.path);
+        if (mapping) {
+          mapping.includes = element.includedMappings.map(
+            (i) =>
+              new MappingInclude(
+                mapping,
+                context.resolveMapping(
+                  guaranteeNonEmptyString(
+                    V1_getIncludedMappingPath(i),
+                    `Mapping include path is missing or empty`,
+                  ),
+                ),
+              ),
+          );
+        }
+      });
+      // handle runtimes
+      const runtimes = [
+        ...graph.ownRuntimes,
+        ...graph.dependencyManager.runtimes,
+      ];
+      const v1Runtimes = graphBuilderInput
+        .map((e) => e.data.elements.filter(filterByType(V1_PackageableRuntime)))
+        .flat();
+      v1Runtimes.forEach((element) => {
+        const runtime = runtimes.find((e) => e.path === element.path);
+        if (runtime) {
+          const runtimeValue = new EngineRuntime();
+          runtime.runtimeValue = runtimeValue;
+          runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) =>
+            context.resolveMapping(mapping.path),
+          );
+        }
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      /**
+       * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
+       * But we might want to rethink this decision in the future and throw appropriate type of error
+       */
+      throw error instanceof GraphBuilderError
+        ? error
+        : new GraphBuilderError(error);
+    }
+  }
+
+  async surveyMappingRuntimeCompatibility(
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<MappingRuntimeCompatibilityAnalysisResult[]> {
+    const result: MappingRuntimeCompatibilityAnalysisResult[] = [];
+    const graph = await this.graphManager.createEmptyGraph({
+      initializeSystem: false,
+    });
+
+    const graphBuilderInput = await this.graphManager.indexLightGraph(
+      graph,
+      entities,
+      dependencyEntities,
+      (entity: Entity): boolean =>
+        ([CORE_PURE_PATH.MAPPING, CORE_PURE_PATH.RUNTIME] as string[]).includes(
+          entity.classifierPath,
+        ),
+      // NOTE: small optimization since we only need to survey runtimes and mappings
+      (entity: Entity): Entity => {
+        if (entity.classifierPath === CORE_PURE_PATH.MAPPING) {
+          entity.content = {
+            _type: entity.content._type,
+            name: entity.content.name,
+            package: entity.content.package,
+            includes: entity.content.includes,
+          };
+        } else if (entity.classifierPath === CORE_PURE_PATH.RUNTIME) {
+          entity.content = {
+            _type: entity.content._type,
+            name: entity.content.name,
+            package: entity.content.package,
+            runtimeValue: {
+              mappings: (
+                entity.content.runtimeValue as
+                  | PlainObject<V1_EngineRuntime>
+                  | undefined
+              )?.mappings,
+            },
+          };
+        }
+        return entity;
+      },
+    );
+
+    const context = new V1_GraphBuilderContextBuilder(
+      graph,
+      graph,
+      this.graphManager.graphBuilderExtensions,
+      this.graphManager.log,
+    ).build();
+
+    graphBuilderInput
+      .map((element) => element.data.elements.filter(filterByType(V1_Mapping)))
+      .flat()
+      .forEach((element) => {
+        const mapping = graph.getNullableMapping(element.path);
+        if (mapping) {
+          mapping.includes = element.includedMappings.map(
+            (include) =>
+              new MappingInclude(
+                mapping,
+                context.resolveMapping(
+                  guaranteeNonEmptyString(
+                    V1_getIncludedMappingPath(include),
+                    `Mapping include path is missing or empty`,
+                  ),
+                ),
+              ),
+          );
+        }
+      });
+
+    graphBuilderInput
+      .map((element) =>
+        element.data.elements.filter(filterByType(V1_PackageableRuntime)),
+      )
+      .flat()
+      .forEach((element) => {
+        const runtime = graph.getNullableRuntime(element.path);
+        if (runtime) {
+          const runtimeValue = new EngineRuntime();
+          runtime.runtimeValue = runtimeValue;
+          runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) =>
+            context.resolveMapping(mapping.path),
+          );
+        }
+      });
+
+    graph.mappings.forEach((mapping) => {
+      const mappingRuntimeCompatibilityAnalysisResult =
+        new MappingRuntimeCompatibilityAnalysisResult();
+      mappingRuntimeCompatibilityAnalysisResult.mapping = mapping;
+      mappingRuntimeCompatibilityAnalysisResult.runtimes =
+        // If the runtime claims to cover some mappings which include the specified mapping,
+        // then we deem the runtime to be compatible with the such mapping
+        graph.runtimes.filter((runtime) =>
+          runtime.runtimeValue.mappings
+            .map((mappingReference) => [
+              mappingReference.value,
+              ...getAllIncludedMappings(mappingReference.value),
+            ])
+            .flat()
+            .includes(mapping),
+        );
+      result.push(mappingRuntimeCompatibilityAnalysisResult);
+    });
+
+    return result;
+  }
+
+  async surveyServiceExecution(
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<ServiceExecutionAnalysisResult[]> {
+    const result: ServiceExecutionAnalysisResult[] = [];
+    const graph = await this.graphManager.createEmptyGraph({
+      initializeSystem: false,
+    });
+
+    const graphBuilderInput = await this.graphManager.indexLightGraph(
+      graph,
+      entities,
+      dependencyEntities,
+      (entity: Entity): boolean =>
+        entity.classifierPath === CORE_PURE_PATH.SERVICE,
+      // NOTE: small optimization since we only need to inspect services' execution context
+      (entity: Entity): Entity => {
+        if (entity.classifierPath === CORE_PURE_PATH.SERVICE) {
+          entity.content = {
+            _type: entity.content._type,
+            name: entity.content.name,
+            package: entity.content.package,
+            execution: entity.content.execution,
+          };
+        }
+        return entity;
+      },
+    );
+    graphBuilderInput
+      .map((element) => element.data.elements.filter(filterByType(V1_Service)))
+      .flat()
+      .forEach((protocol) => {
+        const service = graph.getNullableService(protocol.path);
+        if (service) {
+          const serviceAnalysisResult = new ServiceExecutionAnalysisResult();
+          serviceAnalysisResult.service = service;
+          if (protocol.execution instanceof V1_PureMultiExecution) {
+            serviceAnalysisResult.executionKeys =
+              protocol.execution.executionParameters.map((param) => param.key);
+          }
+          result.push(serviceAnalysisResult);
+        }
+      });
+    return result;
+  }
+}

package/src/index.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 * from './application/LegendQuery.js';
+
+export { QUERY_BUILDER_TEST_ID } from './components/QueryBuilder_TestID.js';
+
+export { QueryBuilder_PureProtocolProcessorPlugin } from './graphManager/protocol/pure/QueryBuilder_PureProtocolProcessorPlugin.js';
+
+export { QueryBuilder } from './components/QueryBuilder.js';
+export {
+  QueryEditorStoreContext,
+  useQueryEditorStore,
+} from './components/QueryEditorStoreProvider.js';
+export { useQuerySetupStore } from './components/QuerySetupStoreProvider.js';
+export {
+  useLegendQueryBaseStore,
+  useLegendQueryApplicationStore,
+} from './components/LegendQueryBaseStoreProvider.js';
+export { QueryEditor } from './components/QueryEditor.js';
+
+export { LegendQueryPluginManager } from './application/LegendQueryPluginManager.js';
+
+export * from './stores/LegendQueryApplicationPlugin.js';
+export * from './stores/LegendQueryRouter.js';
+export { QuerySetupState, QuerySetupStore } from './stores/QuerySetupStore.js';
+export { LegendQueryApplicationConfig } from './application/LegendQueryApplicationConfig.js';
+export {
+  QueryEditorStore,
+  type QueryExportConfiguration,
+} from './stores/QueryEditorStore.js';
+export {
+  LegendQueryBaseStore,
+  type LegendQueryApplicationStore,
+} from './stores/LegendQueryBaseStore.js';
+export {
+  QueryBuilderMode,
+  StandardQueryBuilderMode,
+  QueryBuilderState,
+} from './stores/QueryBuilderState.js';
+export { QueryBuilderExplorerTreeRootNodeData } from './stores/QueryBuilderExplorerState.js';
+export { FETCH_STRUCTURE_MODE } from './stores/QueryBuilderFetchStructureState.js';
+export { COLUMN_SORT_TYPE } from './stores/QueryResultSetModifierState.js';
+export { QueryBuilderSimpleProjectionColumnState } from './stores/QueryBuilderProjectionState.js';

package/src/stores/LegendQueryApplicationPlugin.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 { LegendApplicationPlugin } from '@finos/legend-application';
+import type React from 'react';
+import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
+import type { QueryEditorStore } from './QueryEditorStore.js';
+import type { QuerySetupState, QuerySetupStore } from './QuerySetupStore.js';
+
+export type QuerySetupOptionRendererConfiguration = {
+  key: string;
+  renderer: (setupStore: QuerySetupStore) => React.ReactNode | undefined;
+};
+
+export type QuerySetupRenderer = (
+  setupState: QuerySetupState,
+) => React.ReactNode | undefined;
+
+export type QueryEditorHeaderLabeler = (
+  editorStore: QueryEditorStore,
+) => React.ReactNode | undefined;
+
+export abstract class LegendQueryApplicationPlugin extends LegendApplicationPlugin {
+  /**
+   * This helps to better type-check for this empty abtract type
+   * See https://github.com/finos/legend-studio/blob/master/docs/technical/typescript-usage.md#understand-typescript-structual-type-system
+   */
+  private readonly _$nominalTypeBrand!: 'LegendQueryApplicationPlugin';
+
+  install(pluginManager: LegendQueryPluginManager): void {
+    pluginManager.registerApplicationPlugin(this);
+  }
+
+  /**
+   * Get the list of renderer configurations for the query setup option.
+   */
+  getExtraQuerySetupOptionRendererConfigurations?(): QuerySetupOptionRendererConfiguration[];
+
+  /**
+   * Get the list of renderers for query setup.
+   */
+  getExtraQuerySetupRenderers?(): QuerySetupRenderer[];
+
+  /**
+   * Get the list of query editor header labelers.
+   */
+  getExtraQueryEditorHeaderLabelers?(): QueryEditorHeaderLabeler[];
+}

package/src/stores/LegendQueryBaseStore.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { DepotServerClient } from '@finos/legend-server-depot';
+import type { ApplicationStore } from '@finos/legend-application';
+import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
+import type { LegendQueryApplicationConfig } from '../application/LegendQueryApplicationConfig.js';
+import type { LegendQueryApplicationPlugin } from './LegendQueryApplicationPlugin.js';
+
+export type LegendQueryApplicationStore = ApplicationStore<
+  LegendQueryApplicationConfig,
+  LegendQueryApplicationPlugin
+>;
+
+export class LegendQueryBaseStore {
+  applicationStore: LegendQueryApplicationStore;
+  depotServerClient: DepotServerClient;
+  pluginManager: LegendQueryPluginManager;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+    pluginManager: LegendQueryPluginManager,
+  ) {
+    this.applicationStore = applicationStore;
+    this.depotServerClient = depotServerClient;
+    this.pluginManager = pluginManager;
+
+    // Register plugins
+    this.depotServerClient.setTracerService(
+      this.applicationStore.tracerService,
+    );
+  }
+}

package/src/stores/LegendQueryEventService.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 { EventService } from '@finos/legend-application';
+
+const QUERY_CREATE = 'query_created';
+type QueryCreated_EventData = {
+  queryId: string;
+};
+
+export class LegendQueryEventService {
+  private eventService!: EventService;
+
+  private constructor(eventService: EventService) {
+    this.eventService = eventService;
+  }
+
+  static create(eventService: EventService): LegendQueryEventService {
+    return new LegendQueryEventService(eventService);
+  }
+
+  notify_QueryCreated(data: QueryCreated_EventData): void {
+    this.eventService.notify(QUERY_CREATE, data);
+  }
+}

package/src/stores/LegendQueryRouter.ts

@@ -0,0 +1,114 @@
+/**
+ * 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 { generateGAVCoordinates } from '@finos/legend-server-depot';
+import { generatePath } from 'react-router';
+
+export enum LEGEND_QUERY_PATH_PARAM_TOKEN {
+  GAV = 'gav',
+  QUERY_ID = 'queryId',
+  MAPPING_PATH = 'mappingPath',
+  RUNTIME_PATH = 'runtimePath',
+  SERVICE_PATH = 'servicePath',
+}
+
+export enum LEGEND_QUERY_QUERY_PARAM_TOKEN {
+  CLASS_PATH = 'class',
+  SERVICE_EXECUTION_KEY = 'executionKey',
+}
+
+export const LEGEND_QUERY_ROUTE_PATTERN = Object.freeze({
+  SETUP: '/setup',
+  CREATE_QUERY: `/create/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH}`,
+  SERVICE_QUERY: `/service/:${LEGEND_QUERY_PATH_PARAM_TOKEN.GAV}/:${LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH}`,
+  EXISTING_QUERY: `/edit/:${LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID}`,
+});
+
+export const generateCreateQueryEditorRoute = (
+  groupId: string,
+  artifactId: string,
+  versionId: string,
+  mappingPath: string,
+  runtimePath: string,
+): string =>
+  generatePath(LEGEND_QUERY_ROUTE_PATTERN.CREATE_QUERY, {
+    [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
+      groupId,
+      artifactId,
+      versionId,
+    ),
+    [LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH]: mappingPath,
+    [LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH]: runtimePath,
+  });
+
+export interface CreateQueryPathParams {
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: string;
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.MAPPING_PATH]: string;
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.RUNTIME_PATH]: string;
+}
+
+export interface CreateQueryEditorQueryParams {
+  [LEGEND_QUERY_QUERY_PARAM_TOKEN.CLASS_PATH]?: string;
+}
+
+export const generateServiceQueryEditorRoute = (
+  groupId: string,
+  artifactId: string,
+  versionId: string,
+  servicePath: string,
+  key?: string,
+): string =>
+  `${generatePath(LEGEND_QUERY_ROUTE_PATTERN.SERVICE_QUERY, {
+    [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: generateGAVCoordinates(
+      groupId,
+      artifactId,
+      versionId,
+    ),
+    [LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH]: servicePath,
+  })}${
+    key ? `?${LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY}=${key}` : ''
+  }`;
+
+export interface ServiceQueryEditorPathParams {
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.GAV]: string;
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.SERVICE_PATH]: string;
+}
+
+export interface ServiceQueryEditorQueryParams {
+  [LEGEND_QUERY_QUERY_PARAM_TOKEN.SERVICE_EXECUTION_KEY]?: string;
+}
+
+export const generateExistingQueryEditorRoute = (queryId: string): string =>
+  generatePath(LEGEND_QUERY_ROUTE_PATTERN.EXISTING_QUERY, {
+    [LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID]: queryId,
+  });
+
+export interface ExistingQueryEditorPathParams {
+  [LEGEND_QUERY_PATH_PARAM_TOKEN.QUERY_ID]: string;
+}
+
+export const generateStudioProjectViewUrl = (
+  studioUrl: string,
+  groupId: string,
+  artifactId: string,
+  versionId: string,
+  entityPath: string | undefined,
+): string =>
+  `${studioUrl}/view/archive/${generateGAVCoordinates(
+    groupId,
+    artifactId,
+    versionId,
+  )}${entityPath ? `/entity/${entityPath}` : ''}`;