@finos/legend-extension-dsl-data-space 10.1.91 → 10.1.94

package/src/graph-manager/protocol/pure/DSL_DataSpace_PureProtocolProcessorPlugin.ts

@@ -33,6 +33,7 @@ import {
   UnsupportedOperationError,
   isNonNullable,
   assertType,
+  guaranteeType,
 } from '@finos/legend-shared';
 import { deserialize } from 'serializr';
 import {
@@ -95,6 +96,11 @@ import {
   Package,
   V1_RawValueSpecificationTransformer,
   V1_buildRawLambdaWithResolvedPaths,
+  type V1_ElementPointerType,
+  V1_buildEmbeddedData,
+  V1_transformEmbeddedData,
+  DataElementReference,
+  V1_DataElementReference,
 } from '@finos/legend-graph';
 import { V1_resolveDiagram } from '@finos/legend-extension-dsl-diagram/graph';
 import { V1_MappingIncludeDataSpace } from './v1/model/packageableElements/mapping/V1_DSL_DataSpace_MappingIncludeDataSpace.js';
@@ -103,6 +109,8 @@ import { MappingIncludeDataSpace } from '../../../graph/metamodel/pure/model/pac
 export const DATA_SPACE_ELEMENT_CLASSIFIER_PATH =
   'meta::pure::metamodel::dataSpace::DataSpace';
 
+export const DATA_SPACE_ELEMENT_POINTER = 'DATASPACE';
+
 export class DSL_DataSpace_PureProtocolProcessorPlugin
   extends PureProtocolProcessorPlugin
   implements DSL_Mapping_PureProtocolProcessorPlugin_Extension
@@ -147,6 +155,12 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin
               PackageableElementExplicitReference.create(
                 context.graph.getRuntime(contextProtocol.defaultRuntime.path),
               );
+            execContext.testData = contextProtocol.testData
+              ? guaranteeType(
+                  V1_buildEmbeddedData(contextProtocol.testData, context),
+                  DataElementReference,
+                )
+              : undefined;
             return execContext;
           });
           element.defaultExecutionContext = guaranteeNonNullable(
@@ -314,6 +328,17 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin
     ];
   }
 
+  override V1_getExtraElementPointerTypes(): V1_ElementPointerType[] {
+    return [
+      (elementProtocol: PackageableElement): string | undefined => {
+        if (elementProtocol instanceof DataSpace) {
+          return DATA_SPACE_ELEMENT_POINTER;
+        }
+        return undefined;
+      },
+    ];
+  }
+
   override V1_getExtraElementProtocolSerializers(): V1_ElementProtocolSerializer[] {
     return [
       (
@@ -371,6 +396,12 @@ export class DSL_DataSpace_PureProtocolProcessorPlugin
                 PackageableElementPointerType.RUNTIME,
                 execContext.defaultRuntime.valueForSerialization ?? '',
               );
+              contextProtocol.testData = execContext.testData
+                ? guaranteeType(
+                    V1_transformEmbeddedData(execContext.testData, context),
+                    V1_DataElementReference,
+                  )
+                : undefined;
               return contextProtocol;
             },
           );

package/src/graph-manager/protocol/pure/v1/model/packageableElements/dataSpace/V1_DSL_DataSpace_DataSpace.ts

@@ -23,6 +23,7 @@ import {
   type V1_StereotypePtr,
   type V1_TaggedValue,
   V1_PackageableElement,
+  type V1_DataElementReference,
 } from '@finos/legend-graph';
 
 export class V1_DataSpaceExecutionContext implements Hashable {
@@ -31,6 +32,7 @@ export class V1_DataSpaceExecutionContext implements Hashable {
   description?: string | undefined;
   mapping!: V1_PackageableElementPointer;
   defaultRuntime!: V1_PackageableElementPointer;
+  testData: V1_DataElementReference | undefined;
 
   get hashCode(): string {
     return hashArray([
@@ -40,6 +42,7 @@ export class V1_DataSpaceExecutionContext implements Hashable {
       this.description ?? '',
       this.mapping.path,
       this.defaultRuntime.path,
+      this.testData ?? '',
     ]);
   }
 }

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/V1_DSL_DataSpace_ProtocolHelper.ts

@@ -31,6 +31,7 @@ import {
   V1_packageableElementPointerModelSchema,
   V1_PackageableElementPointer,
   V1_rawLambdaModelSchema,
+  V1_dataElementReferenceModelSchema,
 } from '@finos/legend-graph';
 import {
   type PlainObject,
@@ -71,6 +72,7 @@ const V1_dataSpaceExecutionContextModelSchema = createModelSchema(
     mapping: usingModelSchema(V1_packageableElementPointerModelSchema),
     name: primitive(),
     title: optional(primitive()),
+    testData: optional(usingModelSchema(V1_dataElementReferenceModelSchema)),
   },
 );
 

package/src/stores/query/DataSpaceQueryBuilderState.ts

@@ -146,6 +146,7 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
   dataSpaces: DataSpaceInfo[] = [];
   showRuntimeSelector = false;
   advancedSearchState?: DataSpaceAdvancedSearchState | undefined;
+  isTemplateQueryDialogOpen = false;
 
   constructor(
     applicationStore: GenericLegendApplicationStore,
@@ -172,10 +173,12 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
       executionContext: observable,
       showRuntimeSelector: observable,
       advancedSearchState: observable,
+      isTemplateQueryDialogOpen: observable,
       showAdvancedSearchPanel: action,
       hideAdvancedSearchPanel: action,
       setExecutionContext: action,
       setShowRuntimeSelector: action,
+      setTemplateQueryDialogOpen: action,
       loadDataSpaces: flow,
     });
 
@@ -197,6 +200,10 @@ export class DataSpaceQueryBuilderState extends QueryBuilderState {
       : 'query-builder__setup__data-space';
   }
 
+  setTemplateQueryDialogOpen(val: boolean): void {
+    this.isTemplateQueryDialogOpen = val;
+  }
+
   showAdvancedSearchPanel(): void {
     if (this.projectInfo && this.isAdvancedDataSpaceSearchEnabled) {
       this.advancedSearchState = new DataSpaceAdvancedSearchState(

package/src/stores/query/DataSpaceQueryCreatorStore.ts

@@ -292,12 +292,16 @@ export class DataSpaceQueryCreatorStore extends QueryEditorStore {
         query.groupId = this.groupId;
         query.artifactId = this.artifactId;
         query.versionId = this.versionId;
-        query.taggedValues = [
-          createQueryDataSpaceTaggedValue(this.dataSpacePath),
-          createQueryClassTaggedValue(
-            guaranteeNonNullable(this.queryBuilderState?.class?.path),
-          ),
-        ];
+        if (this.queryBuilderState?.class) {
+          query.taggedValues = [
+            createQueryDataSpaceTaggedValue(this.dataSpacePath),
+            createQueryClassTaggedValue(this.queryBuilderState.class.path),
+          ];
+        } else {
+          query.taggedValues = [
+            createQueryDataSpaceTaggedValue(this.dataSpacePath),
+          ];
+        }
       },
     };
   }

package/src/stores/query/DataSpaceTemplateQueryCreatorStore.ts

@@ -0,0 +1,219 @@
+/**
+ * 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 {
+  extractElementNameFromPath,
+  type Query,
+  type RawLambda,
+} from '@finos/legend-graph';
+import {
+  QueryEditorStore,
+  type QueryPersistConfiguration,
+  type LegendQueryApplicationStore,
+  createViewProjectHandler,
+  createViewSDLCProjectHandler,
+} from '@finos/legend-application-query';
+import {
+  type DepotServerClient,
+  StoreProjectData,
+  LATEST_VERSION_ALIAS,
+} from '@finos/legend-server-depot';
+import { filterByType, guaranteeNonNullable, uuid } from '@finos/legend-shared';
+
+import { getDataSpace } from '../../graph-manager/DSL_DataSpace_GraphManagerHelper.js';
+import {
+  DataSpaceQueryBuilderState,
+  DataSpaceProjectInfo,
+} from './DataSpaceQueryBuilderState.js';
+import type { DataSpaceInfo } from './DataSpaceInfo.js';
+import { generateDataSpaceTemplateQueryCreatorRoute } from '../../__lib__/query/DSL_DataSpace_LegendQueryNavigation.js';
+import {
+  DataSpaceExecutableTemplate,
+  type DataSpaceExecutionContext,
+} from '../../graph/metamodel/pure/model/packageableElements/dataSpace/DSL_DataSpace_DataSpace.js';
+import type { QueryBuilderState } from '@finos/legend-query-builder';
+import type { ProjectGAVCoordinates } from '@finos/legend-storage';
+import { DSL_DataSpace_getGraphManagerExtension } from '../../graph-manager/protocol/pure/DSL_DataSpace_PureGraphManagerExtension.js';
+import { retrieveAnalyticsResultCache } from '../../graph-manager/action/analytics/DataSpaceAnalysisHelper.js';
+import {
+  createQueryDataSpaceTaggedValue,
+  createQueryClassTaggedValue,
+} from './DataSpaceQueryCreatorStore.js';
+
+export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
+  readonly groupId: string;
+  readonly artifactId: string;
+  readonly versionId: string;
+  readonly dataSpacePath: string;
+  readonly templateQueryTitle: string;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+    groupId: string,
+    artifactId: string,
+    versionId: string,
+    dataSpacePath: string,
+    templateQueryTitle: string,
+  ) {
+    super(applicationStore, depotServerClient);
+
+    this.groupId = groupId;
+    this.artifactId = artifactId;
+    this.versionId = versionId;
+    this.dataSpacePath = dataSpacePath;
+    this.templateQueryTitle = templateQueryTitle;
+  }
+
+  getProjectInfo(): ProjectGAVCoordinates {
+    return {
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+    };
+  }
+
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
+    const dataSpace = getDataSpace(
+      this.dataSpacePath,
+      this.graphManagerState.graph,
+    );
+    const dataSpaceExecutableTemplate = guaranteeNonNullable(
+      dataSpace.executables
+        ?.filter(filterByType(DataSpaceExecutableTemplate))
+        .find((executable) => executable.title === this.templateQueryTitle),
+      `Can't find template query with title '${this.templateQueryTitle}'`,
+    );
+    const executionContext = guaranteeNonNullable(
+      dataSpaceExecutableTemplate.executionContextKey
+        ? dataSpace.executionContexts.filter(
+            (ec) => ec.name === dataSpaceExecutableTemplate.executionContextKey,
+          )[0]
+        : dataSpace.defaultExecutionContext,
+      `Can't find execution context '${dataSpaceExecutableTemplate.executionContextKey}'`,
+    );
+
+    let dataSpaceAnalysisResult;
+    try {
+      const project = StoreProjectData.serialization.fromJson(
+        await this.depotServerClient.getProject(this.groupId, this.artifactId),
+      );
+      dataSpaceAnalysisResult = await DSL_DataSpace_getGraphManagerExtension(
+        this.graphManagerState.graphManager,
+      ).retrieveDataSpaceAnalysisFromCache(() =>
+        retrieveAnalyticsResultCache(
+          project,
+          this.versionId,
+          dataSpace.path,
+          this.depotServerClient,
+        ),
+      );
+    } catch {
+      // do nothing
+    }
+    const projectInfo = new DataSpaceProjectInfo(
+      this.groupId,
+      this.artifactId,
+      this.versionId,
+      createViewProjectHandler(this.applicationStore),
+      createViewSDLCProjectHandler(
+        this.applicationStore,
+        this.depotServerClient,
+      ),
+    );
+    const sourceInfo = {
+      groupId: projectInfo.groupId,
+      artifactId: projectInfo.artifactId,
+      versionId: projectInfo.versionId,
+      dataSpace: dataSpace.path,
+    };
+    const queryBuilderState = new DataSpaceQueryBuilderState(
+      this.applicationStore,
+      this.graphManagerState,
+      this.depotServerClient,
+      dataSpace,
+      executionContext,
+      (dataSpaceInfo: DataSpaceInfo) => {
+        if (dataSpaceInfo.defaultExecutionContext) {
+          this.applicationStore.navigationService.navigator.goToLocation(
+            generateDataSpaceTemplateQueryCreatorRoute(
+              guaranteeNonNullable(dataSpaceInfo.groupId),
+              guaranteeNonNullable(dataSpaceInfo.artifactId),
+              LATEST_VERSION_ALIAS, //always default to latest
+              dataSpaceInfo.path,
+              this.templateQueryTitle,
+            ),
+          );
+        } else {
+          this.applicationStore.notificationService.notifyWarning(
+            `Can't switch data space: default execution context not specified`,
+          );
+        }
+      },
+      true,
+      dataSpaceAnalysisResult,
+      (ec: DataSpaceExecutionContext) => {
+        this.applicationStore.navigationService.navigator.updateCurrentLocation(
+          generateDataSpaceTemplateQueryCreatorRoute(
+            this.groupId,
+            this.artifactId,
+            this.versionId,
+            dataSpace.path,
+            this.templateQueryTitle,
+          ),
+        );
+      },
+      undefined,
+      undefined,
+      projectInfo,
+      this.applicationStore.config.options.queryBuilderConfig,
+      sourceInfo,
+    );
+    queryBuilderState.setExecutionContext(executionContext);
+    queryBuilderState.propagateExecutionContextChange(executionContext);
+    queryBuilderState.initializeWithQuery(dataSpaceExecutableTemplate.query);
+    return queryBuilderState;
+  }
+
+  getPersistConfiguration(
+    lambda: RawLambda,
+    options?: { update?: boolean | undefined },
+  ): QueryPersistConfiguration {
+    return {
+      defaultName: options?.update
+        ? `${extractElementNameFromPath(this.dataSpacePath)}`
+        : `New Query for ${extractElementNameFromPath(this.dataSpacePath)}[${
+            this.templateQueryTitle
+          }]`,
+      decorator: (query: Query): void => {
+        query.id = uuid();
+        query.groupId = this.groupId;
+        query.artifactId = this.artifactId;
+        query.versionId = this.versionId;
+        if (this.queryBuilderState?.class) {
+          query.taggedValues = [
+            createQueryDataSpaceTaggedValue(this.dataSpacePath),
+            createQueryClassTaggedValue(this.queryBuilderState.class.path),
+          ];
+        } else {
+          query.taggedValues = [
+            createQueryDataSpaceTaggedValue(this.dataSpacePath),
+          ];
+        }
+      },
+    };
+  }
+}

package/tsconfig.json

@@ -73,6 +73,7 @@
     "./src/stores/query/DataSpaceQueryBuilderState.ts",
     "./src/stores/query/DataSpaceQueryCreatorStore.ts",
     "./src/stores/query/DataSpaceQuerySetupStore.ts",
+    "./src/stores/query/DataSpaceTemplateQueryCreatorStore.ts",
     "./src/stores/studio/DataSpacePreviewState.ts",
     "./src/components/DSL_DataSpace_Icon.tsx",
     "./src/components/DSL_DataSpace_LegendApplicationPlugin.tsx",
@@ -92,8 +93,10 @@
     "./src/components/query/DSL_DataSpace_LegendQueryApplicationPlugin.tsx",
     "./src/components/query/DataSpaceAdvancedSearchModal.tsx",
     "./src/components/query/DataSpaceQueryBuilder.tsx",
+    "./src/components/query/DataSpaceQueryBuilderTemplateQueryPanelContent.tsx",
     "./src/components/query/DataSpaceQueryCreator.tsx",
     "./src/components/query/DataSpaceQuerySetup.tsx",
+    "./src/components/query/DataSpaceTemplateQueryCreator.tsx",
     "./src/components/studio/DSL_DataSpace_LegendStudioApplicationPlugin.tsx",
     "./src/components/studio/DataSpacePreviewAction.tsx",
     "./src/components/studio/DataSpaceQueryAction.tsx",