@finos/legend-application-query 8.1.2 → 9.0.0

package/src/components/UpdateExistingServiceQuerySetup.tsx

@@ -0,0 +1,153 @@
+/**
+ * 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 {
+  ArrowLeftIcon,
+  CustomSelectorInput,
+  SearchIcon,
+  type SelectComponent,
+} from '@finos/legend-art';
+import { debounce, guaranteeType } from '@finos/legend-shared';
+import { flowResult } from 'mobx';
+import { observer, useLocalObservable } from 'mobx-react-lite';
+import { useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { generateQuerySetupRoute } from '../stores/LegendQueryRouter.js';
+import { useDepotServerClient } from '@finos/legend-server-depot';
+import { useLegendQueryApplicationStore } from './LegendQueryBaseStoreProvider.js';
+import { UpdateExistingServiceQuerySetupStore } from '../stores/UpdateExistingServiceQuerySetupStore.js';
+import { BaseQuerySetup, BaseQuerySetupStoreContext } from './QuerySetup.js';
+import {
+  buildServiceOption,
+  formatServiceOptionLabel,
+  type ServiceOption,
+} from '@finos/legend-query-builder';
+
+const UpdateExistingServiceQuerySetupStoreProvider: React.FC<{
+  children: React.ReactNode;
+}> = ({ children }) => {
+  const applicationStore = useLegendQueryApplicationStore();
+  const depotServerClient = useDepotServerClient();
+  const store = useLocalObservable(
+    () =>
+      new UpdateExistingServiceQuerySetupStore(
+        applicationStore,
+        depotServerClient,
+      ),
+  );
+  return (
+    <BaseQuerySetupStoreContext.Provider value={store}>
+      {children}
+    </BaseQuerySetupStoreContext.Provider>
+  );
+};
+
+const useUpdateExistingServiceQuerySetupStore =
+  (): UpdateExistingServiceQuerySetupStore =>
+    guaranteeType(
+      useContext(BaseQuerySetupStoreContext),
+      UpdateExistingServiceQuerySetupStore,
+      `Can't find query setup store in context`,
+    );
+
+const UpdateExistingServiceQuerySetupContent = observer(() => {
+  const applicationStore = useLegendQueryApplicationStore();
+  const setupStore = useUpdateExistingServiceQuerySetupStore();
+  const serviceSearchRef = useRef<SelectComponent>(null);
+  const [searchText, setSearchText] = useState('');
+
+  const back = (): void => {
+    applicationStore.navigator.goToLocation(generateQuerySetupRoute());
+  };
+
+  const serviceOptions = setupStore.services.map(buildServiceOption);
+  const onServiceOptionChange = (option: ServiceOption): void => {
+    setupStore
+      .loadServiceUpdater(option.value)
+      .catch(applicationStore.alertUnhandledError);
+  };
+
+  // search text
+  const debouncedLoadServices = useMemo(
+    () =>
+      debounce((input: string): void => {
+        flowResult(setupStore.loadServices(input)).catch(
+          applicationStore.alertUnhandledError,
+        );
+      }, 500),
+    [applicationStore, setupStore],
+  );
+  const onSearchTextChange = (value: string): void => {
+    if (value !== searchText) {
+      setSearchText(value);
+      debouncedLoadServices.cancel();
+      debouncedLoadServices(value);
+    }
+  };
+
+  useEffect(() => {
+    flowResult(setupStore.loadServices('')).catch(
+      applicationStore.alertUnhandledError,
+    );
+  }, [setupStore, applicationStore]);
+
+  useEffect(() => {
+    serviceSearchRef.current?.focus();
+  }, []);
+
+  return (
+    <div className="query-setup__wizard query-setup__existing-service-query">
+      <div className="query-setup__wizard__header query-setup__existing-service-query__header">
+        <button
+          className="query-setup__wizard__header__btn"
+          onClick={back}
+          title="Back to Main Menu"
+        >
+          <ArrowLeftIcon />
+        </button>
+        <div className="query-setup__wizard__header__title">
+          Updating an existing service query...
+        </div>
+      </div>
+      <div className="query-setup__wizard__content">
+        <div className="query-setup__wizard__group query-setup__wizard__group--inline query-setup__existing-service-query__search-bar">
+          <div className="query-setup__wizard__group__title">
+            <SearchIcon />
+          </div>
+          <CustomSelectorInput
+            ref={serviceSearchRef}
+            className="query-setup__wizard__selector"
+            options={serviceOptions}
+            isLoading={setupStore.loadServicesState.isInProgress}
+            onInputChange={onSearchTextChange}
+            inputValue={searchText}
+            onChange={onServiceOptionChange}
+            placeholder="Search for service..."
+            darkMode={true}
+            formatOptionLabel={formatServiceOptionLabel}
+          />
+        </div>
+      </div>
+    </div>
+  );
+});
+
+export const UpdateExistingServiceQuerySetup: React.FC = () => (
+  <UpdateExistingServiceQuerySetupStoreProvider>
+    <BaseQuerySetup>
+      <UpdateExistingServiceQuerySetupContent />
+    </BaseQuerySetup>
+  </UpdateExistingServiceQuerySetupStoreProvider>
+);

package/src/index.ts

@@ -22,16 +22,17 @@ export {
   QueryEditorStoreContext,
   useQueryEditorStore,
 } from './components/QueryEditorStoreProvider.js';
-export { useQuerySetupStore } from './components/QuerySetupStoreProvider.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 { BaseQuerySetupStore } from './stores/QuerySetupStore.js';
 export { LegendQueryApplicationConfig } from './application/LegendQueryApplicationConfig.js';
 export {
+  createViewProjectHandler,
+  createViewSDLCProjectHandler,
   QueryEditorStore,
   ExistingQueryEditorStore,
   type QueryExportConfiguration,

package/src/stores/CloneServiceQuerySetupStore.ts

@@ -0,0 +1,151 @@
+/**
+ * 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 {
+  getQueryBuilderGraphManagerExtension,
+  type ServiceExecutionAnalysisResult,
+} from '@finos/legend-query-builder';
+import {
+  type DepotServerClient,
+  ProjectData,
+} from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  LogEvent,
+  type PlainObject,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import type { Entity } from '@finos/legend-storage';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import { LEGEND_QUERY_APP_EVENT } from '../LegendQueryAppEvent.js';
+import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { BaseQuerySetupStore } from './QuerySetupStore.js';
+import type { Service } from '@finos/legend-graph';
+
+export interface ServiceExecutionOption {
+  service: Service;
+  key?: string | undefined;
+}
+
+export class CloneServiceQuerySetupStore extends BaseQuerySetupStore {
+  projects: ProjectData[] = [];
+  loadProjectsState = ActionState.create();
+  loadServiceExecutionsState = ActionState.create();
+  currentProject?: ProjectData | undefined;
+  currentVersionId?: string | undefined;
+  currentServiceExecutionOption?: ServiceExecutionOption | undefined;
+  serviceExecutionOptions: ServiceExecutionOption[] = [];
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+  ) {
+    super(applicationStore, depotServerClient);
+
+    makeObservable(this, {
+      serviceExecutionOptions: observable,
+      projects: observable,
+      currentProject: observable,
+      currentVersionId: observable,
+      currentServiceExecutionOption: observable,
+      setCurrentProject: action,
+      setCurrentVersionId: action,
+      setCurrentServiceExecutionOption: action,
+      setServiceExecutionOptions: action,
+      loadProjects: flow,
+      loadServiceExecutionOptions: flow,
+    });
+  }
+
+  setCurrentProject(val: ProjectData | undefined): void {
+    this.currentProject = val;
+  }
+
+  setCurrentVersionId(val: string | undefined): void {
+    this.currentVersionId = val;
+  }
+
+  setCurrentServiceExecutionOption(
+    val: ServiceExecutionOption | undefined,
+  ): void {
+    this.currentServiceExecutionOption = val;
+  }
+
+  setServiceExecutionOptions(val: ServiceExecutionOption[]): void {
+    this.serviceExecutionOptions = val;
+  }
+
+  *loadProjects(): GeneratorFn<void> {
+    this.loadProjectsState.inProgress();
+    try {
+      this.projects = (
+        (yield this.depotServerClient.getProjects()) as PlainObject<ProjectData>[]
+      ).map((v) => ProjectData.serialization.fromJson(v));
+      this.loadProjectsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadProjectsState.fail();
+    }
+  }
+
+  *loadServiceExecutionOptions(
+    project: ProjectData,
+    versionId: string,
+  ): GeneratorFn<void> {
+    this.loadServiceExecutionsState.inProgress();
+    try {
+      // fetch entities and dependencies
+      const entities = (yield this.depotServerClient.getEntities(
+        project,
+        versionId,
+      )) as Entity[];
+      const dependencyEntitiesIndex = (yield flowResult(
+        this.depotServerClient.getIndexedDependencyEntities(project, versionId),
+      )) as Map<string, Entity[]>;
+
+      const serviceExecutionAnalysisResults = (yield flowResult(
+        getQueryBuilderGraphManagerExtension(
+          this.graphManagerState.graphManager,
+        ).surveyServiceExecution(entities, dependencyEntitiesIndex),
+      )) as ServiceExecutionAnalysisResult[];
+
+      this.setServiceExecutionOptions(
+        serviceExecutionAnalysisResults.flatMap((result) => {
+          if (result.executionKeys?.length) {
+            return result.executionKeys.map((key) => ({
+              service: result.service,
+              key,
+            }));
+          }
+          return {
+            service: result.service,
+          };
+        }),
+      );
+      this.loadServiceExecutionsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+      this.loadServiceExecutionsState.fail();
+    }
+  }
+}

package/src/stores/CreateMappingQuerySetupStore.ts

@@ -0,0 +1,155 @@
+/**
+ * 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 { Mapping, PackageableRuntime } from '@finos/legend-graph';
+import {
+  getQueryBuilderGraphManagerExtension,
+  type MappingRuntimeCompatibilityAnalysisResult,
+} from '@finos/legend-query-builder';
+import {
+  type DepotServerClient,
+  ProjectData,
+} from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  LogEvent,
+  type PlainObject,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import type { Entity } from '@finos/legend-storage';
+import {
+  action,
+  computed,
+  flow,
+  flowResult,
+  makeObservable,
+  observable,
+} from 'mobx';
+import { LEGEND_QUERY_APP_EVENT } from '../LegendQueryAppEvent.js';
+import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { BaseQuerySetupStore } from './QuerySetupStore.js';
+
+export class CreateMappingQuerySetupStore extends BaseQuerySetupStore {
+  readonly loadProjectsState = ActionState.create();
+  readonly surveyMappingRuntimeCompatibilityState = ActionState.create();
+
+  projects: ProjectData[] = [];
+  currentProject?: ProjectData | undefined;
+  currentVersionId?: string | undefined;
+  currentMapping?: Mapping | undefined;
+  currentRuntime?: PackageableRuntime | undefined;
+  mappingRuntimeCompatibilitySurveyResult: MappingRuntimeCompatibilityAnalysisResult[] =
+    [];
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+  ) {
+    super(applicationStore, depotServerClient);
+
+    makeObservable(this, {
+      projects: observable,
+      currentProject: observable,
+      currentVersionId: observable,
+      currentMapping: observable,
+      currentRuntime: observable,
+      mappingRuntimeCompatibilitySurveyResult: observable,
+      compatibleRuntimes: computed,
+      setCurrentProject: action,
+      setCurrentVersionId: action,
+      setCurrentMapping: action,
+      setCurrentRuntime: action,
+      loadProjects: flow,
+      surveyMappingRuntimeCompatibility: flow,
+    });
+  }
+
+  setCurrentProject(val: ProjectData | undefined): void {
+    this.currentProject = val;
+  }
+
+  setCurrentVersionId(val: string | undefined): void {
+    this.currentVersionId = val;
+  }
+
+  setCurrentMapping(val: Mapping | undefined): void {
+    this.currentMapping = val;
+  }
+
+  setCurrentRuntime(val: PackageableRuntime | undefined): void {
+    this.currentRuntime = val;
+  }
+
+  get compatibleRuntimes(): PackageableRuntime[] {
+    const currentMapping = this.currentMapping;
+    if (!currentMapping) {
+      return [];
+    }
+    return (
+      this.mappingRuntimeCompatibilitySurveyResult.find(
+        (result) => result.mapping === currentMapping,
+      )?.runtimes ?? []
+    );
+  }
+
+  *loadProjects(): GeneratorFn<void> {
+    this.loadProjectsState.inProgress();
+    try {
+      this.projects = (
+        (yield this.depotServerClient.getProjects()) as PlainObject<ProjectData>[]
+      ).map((v) => ProjectData.serialization.fromJson(v));
+      this.loadProjectsState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadProjectsState.fail();
+    }
+  }
+
+  *surveyMappingRuntimeCompatibility(
+    project: ProjectData,
+    versionId: string,
+  ): GeneratorFn<void> {
+    this.surveyMappingRuntimeCompatibilityState.inProgress();
+    try {
+      // fetch entities and dependencies
+      const entities = (yield this.depotServerClient.getEntities(
+        project,
+        versionId,
+      )) as Entity[];
+      const dependencyEntitiesIndex = (yield flowResult(
+        this.depotServerClient.getIndexedDependencyEntities(project, versionId),
+      )) as Map<string, Entity[]>;
+
+      this.mappingRuntimeCompatibilitySurveyResult = (yield flowResult(
+        getQueryBuilderGraphManagerExtension(
+          this.graphManagerState.graphManager,
+        ).surveyMappingRuntimeCompatibility(entities, dependencyEntitiesIndex),
+      )) as MappingRuntimeCompatibilityAnalysisResult[];
+
+      this.surveyMappingRuntimeCompatibilityState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.log.error(
+        LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
+        error,
+      );
+      this.applicationStore.notifyError(error);
+      this.surveyMappingRuntimeCompatibilityState.fail();
+    }
+  }
+}

package/src/stores/EditExistingQuerySetupStore.ts

@@ -0,0 +1,111 @@
+/**
+ * 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 {
+  DEFAULT_TYPEAHEAD_SEARCH_LIMIT,
+  DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
+} from '@finos/legend-application';
+import {
+  QuerySearchSpecification,
+  type LightQuery,
+  type QueryInfo,
+} from '@finos/legend-graph';
+import type { DepotServerClient } from '@finos/legend-server-depot';
+import {
+  ActionState,
+  assertErrorThrown,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { action, flow, makeObservable, observable } from 'mobx';
+import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { BaseQuerySetupStore } from './QuerySetupStore.js';
+
+export class EditExistingQuerySetupStore extends BaseQuerySetupStore {
+  readonly loadQueriesState = ActionState.create();
+  readonly loadQueryState = ActionState.create();
+
+  queries: LightQuery[] = [];
+  currentQuery?: LightQuery | undefined;
+  currentQueryInfo?: QueryInfo | undefined;
+  showCurrentUserQueriesOnly = false;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+  ) {
+    super(applicationStore, depotServerClient);
+
+    makeObservable(this, {
+      queries: observable,
+      currentQuery: observable,
+      currentQueryInfo: observable,
+      showCurrentUserQueriesOnly: observable,
+      setShowCurrentUserQueriesOnly: action,
+      setCurrentQuery: flow,
+      loadQueries: flow,
+    });
+  }
+
+  setShowCurrentUserQueriesOnly(val: boolean): void {
+    this.showCurrentUserQueriesOnly = val;
+  }
+
+  *setCurrentQuery(queryId: string | undefined): GeneratorFn<void> {
+    if (queryId) {
+      try {
+        this.loadQueryState.inProgress();
+        this.currentQuery =
+          (yield this.graphManagerState.graphManager.getLightQuery(
+            queryId,
+          )) as LightQuery;
+        this.currentQueryInfo =
+          (yield this.graphManagerState.graphManager.getQueryInfo(
+            queryId,
+          )) as QueryInfo;
+      } catch (error) {
+        assertErrorThrown(error);
+        this.applicationStore.notifyError(error);
+      } finally {
+        this.loadQueryState.reset();
+      }
+    } else {
+      this.currentQuery = undefined;
+    }
+  }
+
+  *loadQueries(searchText: string): GeneratorFn<void> {
+    const isValidSearchString =
+      searchText.length >= DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH;
+    this.loadQueriesState.inProgress();
+    try {
+      const searchSpecification = new QuerySearchSpecification();
+      searchSpecification.searchTerm = isValidSearchString
+        ? searchText
+        : undefined;
+      searchSpecification.limit = DEFAULT_TYPEAHEAD_SEARCH_LIMIT;
+      searchSpecification.showCurrentUserQueriesOnly =
+        this.showCurrentUserQueriesOnly;
+      this.queries = (yield this.graphManagerState.graphManager.searchQueries(
+        searchSpecification,
+      )) as LightQuery[];
+      this.loadQueriesState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notifyError(error);
+      this.loadQueriesState.fail();
+    }
+  }
+}

package/src/stores/LegendQueryApplicationPlugin.ts

@@ -19,25 +19,35 @@ import type { Query } from '@finos/legend-graph';
 import type { QueryBuilderState } from '@finos/legend-query-builder';
 import type React from 'react';
 import type { LegendQueryPluginManager } from '../application/LegendQueryPluginManager.js';
-import type {
-  ExistingQueryEditorStore,
-  QueryEditorStore,
-} from './QueryEditorStore.js';
-import type { QuerySetupState, QuerySetupStore } from './QuerySetupStore.js';
+import type { ExistingQueryEditorStore } from './QueryEditorStore.js';
+import type { QuerySetupLandingPageStore } from './QuerySetupStore.js';
 
-export type QuerySetupOptionRendererConfiguration = {
+export enum QuerySetupActionTag {
+  PRODUCTIONIZATION = 'Productionization',
+}
+
+export type QuerySetupActionConfiguration = {
   key: string;
-  renderer: (setupStore: QuerySetupStore) => React.ReactNode | undefined;
+  isCreateAction: boolean;
+  isAdvanced: boolean;
+  /**
+   * NOTE: we could potentially support multiple tags, but for simplicity
+   * we will only limit this to one
+   *
+   * If no tag is provided, the action will be classified into the default group
+   */
+  tag?: string;
+  // NOTE: we could have an advanced option for rendering, i.e. specifying the
+  // component for the button, this gives a lot of flexibility and could facilitate
+  // powerful interaction like click to open modal dialog, etc., but this allows
+  // too much customization, so we will not have that for now
+  //
+  label: string;
+  icon: React.ReactNode;
+  className?: string | undefined;
+  action: (setupStore: QuerySetupLandingPageStore) => Promise<void>;
 };
 
-export type QuerySetupRenderer = (
-  setupState: QuerySetupState,
-) => React.ReactNode | undefined;
-
-export type QueryEditorHeaderLabeler = (
-  editorStore: QueryEditorStore,
-) => React.ReactNode | undefined;
-
 export type ExistingQueryEditorStateBuilder = (
   query: Query,
   editorStore: ExistingQueryEditorStore,
@@ -63,19 +73,9 @@ export abstract class LegendQueryApplicationPlugin extends LegendApplicationPlug
   }
 
   /**
-   * 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.
+   * Get the list of actions (configurations) for query setup.
    */
-  getExtraQueryEditorHeaderLabelers?(): QueryEditorHeaderLabeler[];
+  getExtraQuerySetupActionConfigurations?(): QuerySetupActionConfiguration[];
 
   /**
    * Get the list of existing query editor state builders.