@finos/legend-extension-dsl-data-space-studio 0.1.340 → 0.1.342

package/src/components/DataSpaceQueryAction.tsx

@@ -21,7 +21,7 @@ import {
   useEditorStore,
 } from '@finos/legend-application-studio';
 import { flowResult } from 'mobx';
-import { guaranteeType } from '@finos/legend-shared';
+import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
 import {
   DataSpace,
   resolveUsableDataSpaceClasses,
@@ -41,6 +41,10 @@ export const queryDataSpace = async (
   editorStore: EditorStore,
 ): Promise<void> => {
   const embeddedQueryBuilderState = editorStore.embeddedQueryBuilderState;
+  const initialDefaultExecutionContext = guaranteeNonNullable(
+    dataSpace.defaultExecutionContext,
+    `Can't query data product '${dataSpace.path}': no default execution context defined`,
+  );
   await flowResult(
     embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration({
       setupQueryBuilderState: async () => {
@@ -57,7 +61,7 @@ export const queryDataSpace = async (
           QueryBuilderAdvancedWorkflowState.INSTANCE,
           QueryBuilderActionConfig.INSTANCE,
           dataSpace,
-          dataSpace.defaultExecutionContext,
+          initialDefaultExecutionContext,
           false,
           undefined,
           async (dataSpaceInfo: ResolvedDataSpaceEntityWithOrigin) => {
@@ -67,9 +71,11 @@ export const queryDataSpace = async (
               ),
               DataSpace,
             );
-            queryBuilderState.setExecutionContext(
+            const targetDefault = guaranteeNonNullable(
               queryBuilderState.dataSpace.defaultExecutionContext,
+              `Can't query data product '${queryBuilderState.dataSpace.path}': no default execution context defined`,
             );
+            queryBuilderState.setExecutionContext(targetDefault);
             await queryBuilderState.propagateExecutionContextChange();
           },
           undefined,
@@ -79,10 +85,11 @@ export const queryDataSpace = async (
           editorStore.applicationStore.config.options.queryBuilderConfig,
           sourceInfo,
         );
-        queryBuilderState.setExecutionContext(
-          dataSpace.defaultExecutionContext,
-        );
-        const mapping = queryBuilderState.executionContext.mapping.value;
+        queryBuilderState.setExecutionContext(initialDefaultExecutionContext);
+        const mapping = guaranteeNonNullable(
+          queryBuilderState.executionContext.mapping,
+          `Can't query execution context '${queryBuilderState.executionContext.name}': no mapping configured`,
+        ).value;
         queryBuilderState.changeMapping(mapping);
         const mappingModelCoverageAnalysisResult =
           queryBuilderState.dataSpaceAnalysisResult?.mappingToMappingCoverageResult?.get(
@@ -92,16 +99,16 @@ export const queryDataSpace = async (
           queryBuilderState.explorerState.mappingModelCoverageAnalysisResult =
             mappingModelCoverageAnalysisResult;
         }
-        queryBuilderState.changeRuntime(
-          new RuntimePointer(queryBuilderState.executionContext.defaultRuntime),
-        );
+        const defaultRuntime =
+          queryBuilderState.executionContext.defaultRuntime;
+        if (defaultRuntime) {
+          queryBuilderState.changeRuntime(new RuntimePointer(defaultRuntime));
+        }
         const compatibleClasses = resolveUsableDataSpaceClasses(
           queryBuilderState.dataSpace,
           mapping,
           queryBuilderState.graphManagerState,
         );
-        // if there is no chosen class or the chosen one is not compatible
-        // with the mapping then pick a compatible class if possible
         if (
           !queryBuilderState.sourceClass ||
           !compatibleClasses.includes(queryBuilderState.sourceClass)

package/src/stores/DataSpaceEditorState.ts

@@ -36,24 +36,42 @@ import {
 } from '@finos/legend-extension-dsl-data-space/graph';
 import { guaranteeType } from '@finos/legend-shared';
 import { DataSpaceExecutionContextState } from './DataSpaceExecutionContextState.js';
+import { DataSpaceExecutableTemplateStateCache } from './DataSpaceExecutableTemplateState.js';
+
+export enum DATA_SPACE_TAB {
+  HOME = 'Home',
+  EXECUTION_CONTEXTS = 'Execution Contexts',
+  EXECUTABLES = 'Executables',
+}
 
 export class DataSpaceEditorState extends ElementEditorState {
   executionContextState: DataSpaceExecutionContextState;
+  readonly executableTemplateStates: DataSpaceExecutableTemplateStateCache;
+  selectedTab = DATA_SPACE_TAB.HOME;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {
     super(editorStore, element);
 
     makeObservable(this, {
       executionContextState: observable,
+      selectedTab: observable,
       dataSpace: computed,
       reprocess: action,
       isValidDataSpaceElement: action,
       getDataSpaceElementOptions: action,
       getDiagramOptions: action,
       getDataSpaceExecutableOptions: action,
+      setSelectedTab: action,
     });
 
     this.executionContextState = new DataSpaceExecutionContextState(this);
+    this.executableTemplateStates = new DataSpaceExecutableTemplateStateCache(
+      editorStore,
+    );
+  }
+
+  setSelectedTab(tab: DATA_SPACE_TAB): void {
+    this.selectedTab = tab;
   }
 
   isValidDataSpaceElement(

package/src/stores/DataSpaceExecutableTemplateState.ts

@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2026-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 { EditorStore } from '@finos/legend-application-studio';
+import {
+  GRAPH_MANAGER_EVENT,
+  isStubbed_RawLambda,
+  LAMBDA_PIPE,
+  ParserError,
+  RawLambda,
+} from '@finos/legend-graph';
+import { LambdaEditorState } from '@finos/legend-query-builder';
+import {
+  assertErrorThrown,
+  LogEvent,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import type { DataSpaceExecutableTemplate } from '@finos/legend-extension-dsl-data-space/graph';
+
+/**
+ * A fully empty `RawLambda` (no body, no parameters) is not valid PURE and
+ * will fail to compile once it's part of the graph — e.g. the very first
+ * `analyzeMappingModelCoverage` call made when opening Query Builder sends
+ * the full graph model to engine for compilation. A newly created inline
+ * executable therefore needs a self-contained, always-valid placeholder
+ * query (an empty string literal) rather than `stub_RawLambda()`.
+ */
+export const stub_DataSpaceExecutableTemplateQuery = (): RawLambda =>
+  new RawLambda([], [{ _type: 'string', value: '' }]);
+
+export class DataSpaceExecutableTemplateLambdaState extends LambdaEditorState {
+  readonly editorStore: EditorStore;
+  readonly executableTemplate: DataSpaceExecutableTemplate;
+  lastComputedLambdaString: string | undefined;
+
+  constructor(
+    editorStore: EditorStore,
+    executableTemplate: DataSpaceExecutableTemplate,
+  ) {
+    super('', LAMBDA_PIPE, { typeAheadEnabled: true });
+    this.editorStore = editorStore;
+    this.executableTemplate = executableTemplate;
+  }
+
+  override get lambdaId(): string {
+    return `data-space-executable-template-${this.executableTemplate.title}`;
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    if (this.lambdaString === this.lastComputedLambdaString) {
+      return;
+    }
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        this.executableTemplate.query = lambda;
+        this.lastComputedLambdaString = this.lambdaString;
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(options?: {
+    pretty?: boolean | undefined;
+    preserveCompilationError?: boolean | undefined;
+  }): GeneratorFn<void> {
+    if (!isStubbed_RawLambda(this.executableTemplate.query)) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(this.lambdaId, this.executableTemplate.query);
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            options?.pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        const nextLambdaString =
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '';
+        this.setLambdaString(nextLambdaString);
+        this.lastComputedLambdaString = nextLambdaString || undefined;
+        this.clearErrors({
+          preserveCompilationError: options?.preserveCompilationError,
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+}
+
+export class DataSpaceExecutableTemplateStateCache {
+  readonly editorStore: EditorStore;
+  private readonly states = new Map<
+    DataSpaceExecutableTemplate,
+    DataSpaceExecutableTemplateLambdaState
+  >();
+
+  constructor(editorStore: EditorStore) {
+    this.editorStore = editorStore;
+  }
+
+  getLambdaState(
+    executableTemplate: DataSpaceExecutableTemplate,
+  ): DataSpaceExecutableTemplateLambdaState {
+    let state = this.states.get(executableTemplate);
+    if (!state) {
+      state = new DataSpaceExecutableTemplateLambdaState(
+        this.editorStore,
+        executableTemplate,
+      );
+      this.states.set(executableTemplate, state);
+    }
+    return state;
+  }
+}

package/src/stores/DataSpaceExecutionContextState.ts

@@ -15,50 +15,35 @@
  */
 
 import type { EditorStore } from '@finos/legend-application-studio';
-import { action, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable } from 'mobx';
 import type { DataSpaceEditorState } from './DataSpaceEditorState.js';
-import {
+import type {
+  DataSpace,
   DataSpaceExecutionContext,
-  type DataSpace,
 } from '@finos/legend-extension-dsl-data-space/graph';
 import {
   dataSpace_addExecutionContext,
   dataSpace_removeExecutionContext,
-  dataSpace_setExecutionContextDefaultRuntime,
-  dataSpace_setExecutionContextName,
 } from './studio/DSL_DataSpace_GraphModifierHelper.js';
-import {
-  PackageableElementExplicitReference,
-  stub_Mapping,
-  stub_PackageableRuntime,
-  type Mapping,
-  type PackageableRuntime,
-} from '@finos/legend-graph';
 
 export class DataSpaceExecutionContextState {
   readonly dataSpaceEditorState: DataSpaceEditorState;
   readonly editorStore: EditorStore;
-  executionContexts: DataSpaceExecutionContext[];
   selectedExecutionContext: DataSpaceExecutionContext | undefined;
   newExecutionContextModal = false;
-  executionContextToRename: DataSpaceExecutionContext | undefined;
 
   constructor(dataSpaceEditorState: DataSpaceEditorState) {
     makeObservable(this, {
-      executionContexts: observable,
       selectedExecutionContext: observable,
-      executionContextToRename: observable,
       newExecutionContextModal: observable,
+      executionContexts: computed,
       addExecutionContext: action,
       removeExecutionContext: action,
-      renameExecutionContext: action,
       setSelectedExecutionContext: action,
-      setExecutionContextToRename: action,
       setNewExecutionContextModal: action,
     });
-    this.executionContexts = dataSpaceEditorState.dataSpace.executionContexts;
     this.selectedExecutionContext =
-      dataSpaceEditorState.dataSpace.executionContexts[0];
+      dataSpaceEditorState.dataSpace.executionContexts?.[0];
     this.dataSpaceEditorState = dataSpaceEditorState;
     this.editorStore = dataSpaceEditorState.editorStore;
   }
@@ -67,69 +52,31 @@ export class DataSpaceExecutionContextState {
     return this.dataSpaceEditorState.dataSpace;
   }
 
-  addExecutionContext(name: string): void {
-    const val = new DataSpaceExecutionContext();
-    val.name = name;
-    const mapping = this.editorStore.graphManagerState.usableMappings[0];
-    const runtime = mapping
-      ? this.editorStore.graphManagerState.graph.ownRuntimes.filter(
-          (_runtime) =>
-            _runtime.runtimeValue.mappings
-              .map((m) => m.value)
-              .includes(mapping),
-        )[0]
-      : undefined;
-    val.mapping = PackageableElementExplicitReference.create(
-      mapping ?? stub_Mapping(),
-    );
-    val.defaultRuntime = PackageableElementExplicitReference.create(
-      runtime ?? stub_PackageableRuntime(),
-    );
-    dataSpace_addExecutionContext(this.dataSpace, val);
-    this.selectedExecutionContext = val;
+  get executionContexts(): DataSpaceExecutionContext[] {
+    return this.dataSpace.executionContexts ?? [];
   }
 
-  removeExecutionContext(
-    dataSpaceExecutionContext: DataSpaceExecutionContext,
-  ): void {
-    dataSpace_removeExecutionContext(this.dataSpace, dataSpaceExecutionContext);
+  addExecutionContext(executionContext: DataSpaceExecutionContext): void {
+    dataSpace_addExecutionContext(this.dataSpace, executionContext);
+    this.selectedExecutionContext = executionContext;
   }
 
-  renameExecutionContext(
+  removeExecutionContext(
     dataSpaceExecutionContext: DataSpaceExecutionContext,
-    newName: string,
   ): void {
-    dataSpace_setExecutionContextName(dataSpaceExecutionContext, newName);
-  }
-
-  setSelectedExecutionContext(val: DataSpaceExecutionContext): void {
-    this.selectedExecutionContext = val;
+    dataSpace_removeExecutionContext(this.dataSpace, dataSpaceExecutionContext);
+    if (this.selectedExecutionContext === dataSpaceExecutionContext) {
+      this.selectedExecutionContext = this.executionContexts[0];
+    }
   }
 
-  setExecutionContextToRename(
+  setSelectedExecutionContext(
     val: DataSpaceExecutionContext | undefined,
   ): void {
-    this.executionContextToRename = val;
+    this.selectedExecutionContext = val;
   }
 
   setNewExecutionContextModal(val: boolean): void {
     this.newExecutionContextModal = val;
   }
-
-  autoSelectRuntimeOnMappingChange(mapping: Mapping): void {
-    if (this.selectedExecutionContext) {
-      const runtimes =
-        this.editorStore.graphManagerState.graph.ownRuntimes.filter((runtime) =>
-          runtime.runtimeValue.mappings.map((m) => m.value).includes(mapping),
-        );
-      if (runtimes.length) {
-        dataSpace_setExecutionContextDefaultRuntime(
-          this.selectedExecutionContext,
-          PackageableElementExplicitReference.create(
-            runtimes[0] as PackageableRuntime,
-          ),
-        );
-      }
-    }
-  }
 }

package/src/stores/studio/DSL_DataSpace_GraphModifierHelper.ts

@@ -21,15 +21,19 @@ import {
   type DataSpaceElementPointer,
   type DataSpaceExecutable,
   type DataSpaceExecutionContext,
+  type DataSpaceMappingProvider,
   type DataSpaceSupportCombinedInfo,
   type DataSpaceSupportEmail,
   type DataSpaceSupportInfo,
   observe_DataSpaceDiagram,
   observe_DataSpaceElementPointer,
+  observe_DataSpaceExecutable,
   observe_DataSpaceExecutionContext,
+  observe_DataSpaceMappingProvider,
   observe_DataSpaceSupportInfo,
 } from '@finos/legend-extension-dsl-data-space/graph';
 import type {
+  PackageableElement,
   PackageableElementReference,
   Mapping,
   PackageableRuntime,
@@ -54,7 +58,7 @@ export const dataSpace_setDescription = action(
 export const dataSpace_setExecutionContexts = action(
   (
     dataSpace: DataSpace,
-    executionContexts: DataSpaceExecutionContext[],
+    executionContexts: DataSpaceExecutionContext[] | undefined,
   ): void => {
     dataSpace.executionContexts = executionContexts;
   },
@@ -63,7 +67,7 @@ export const dataSpace_setExecutionContexts = action(
 export const dataSpace_setDefaultExecutionContext = action(
   (
     dataSpace: DataSpace,
-    defaultExecutionContext: DataSpaceExecutionContext,
+    defaultExecutionContext: DataSpaceExecutionContext | undefined,
   ): void => {
     dataSpace.defaultExecutionContext = defaultExecutionContext;
   },
@@ -108,6 +112,9 @@ export const dataSpace_setSupportInfo = action(
 // Array item management
 export const dataSpace_addExecutionContext = action(
   (dataSpace: DataSpace, executionContext: DataSpaceExecutionContext): void => {
+    if (!dataSpace.executionContexts) {
+      dataSpace.executionContexts = [];
+    }
     addUniqueEntry(
       dataSpace.executionContexts,
       observe_DataSpaceExecutionContext(executionContext),
@@ -120,10 +127,21 @@ export const dataSpace_removeExecutionContext = action(
     dataSpace: DataSpace,
     dataSpaceExecutionContext: DataSpaceExecutionContext,
   ): void => {
+    if (!dataSpace.executionContexts) {
+      return;
+    }
     const index = dataSpace.executionContexts.indexOf(
       dataSpaceExecutionContext,
     );
-    dataSpace.executionContexts.splice(index, 1);
+    if (index !== -1) {
+      dataSpace.executionContexts.splice(index, 1);
+    }
+    if (dataSpace.executionContexts.length === 0) {
+      dataSpace.executionContexts = undefined;
+    }
+    if (dataSpace.defaultExecutionContext === dataSpaceExecutionContext) {
+      dataSpace.defaultExecutionContext = undefined;
+    }
   },
 );
 
@@ -159,7 +177,7 @@ export const dataSpace_addExecutable = action(
     if (!dataSpace.executables) {
       dataSpace.executables = [];
     }
-    dataSpace.executables.push(executable);
+    dataSpace.executables.push(observe_DataSpaceExecutable(executable));
   },
 );
 
@@ -172,6 +190,27 @@ export const dataSpace_removeExecutable = action(
   },
 );
 
+export const dataSpace_setExecutableTitle = action(
+  (executable: DataSpaceExecutable, title: string): void => {
+    executable.title = title;
+  },
+);
+
+export const dataSpace_setExecutableDescription = action(
+  (executable: DataSpaceExecutable, description: string | undefined): void => {
+    executable.description = description;
+  },
+);
+
+export const dataSpace_setExecutableExecutionContextKey = action(
+  (
+    executable: DataSpaceExecutable,
+    executionContextKey: string | undefined,
+  ): void => {
+    executable.executionContextKey = executionContextKey;
+  },
+);
+
 export const dataSpace_addDiagram = action(
   (dataSpace: DataSpace, diagram: DataSpaceDiagram): void => {
     if (!dataSpace.diagrams) {
@@ -232,21 +271,55 @@ export const dataSpace_setExecutionContextDescription = action(
 export const dataSpace_setExecutionContextMapping = action(
   (
     executionContext: DataSpaceExecutionContext,
-    mapping: PackageableElementReference<Mapping>,
+    mapping: PackageableElementReference<Mapping> | undefined,
   ): void => {
     executionContext.mapping = mapping;
+    if (mapping) {
+      executionContext.mappingProvider = undefined;
+    }
   },
 );
 
 export const dataSpace_setExecutionContextDefaultRuntime = action(
   (
     executionContext: DataSpaceExecutionContext,
-    defaultRuntime: PackageableElementReference<PackageableRuntime>,
+    defaultRuntime: PackageableElementReference<PackageableRuntime> | undefined,
   ): void => {
     executionContext.defaultRuntime = defaultRuntime;
   },
 );
 
+export const dataSpace_setExecutionContextMappingProvider = action(
+  (
+    executionContext: DataSpaceExecutionContext,
+    mappingProvider: DataSpaceMappingProvider | undefined,
+  ): void => {
+    executionContext.mappingProvider =
+      mappingProvider !== undefined
+        ? observe_DataSpaceMappingProvider(mappingProvider)
+        : undefined;
+    if (mappingProvider) {
+      executionContext.mapping = undefined;
+    }
+  },
+);
+
+export const dataSpace_setMappingProviderElement = action(
+  (
+    mappingProvider: DataSpaceMappingProvider,
+    element: PackageableElementReference<PackageableElement>,
+  ): void => {
+    mappingProvider.element = element;
+    mappingProvider.keys = [];
+  },
+);
+
+export const dataSpace_setMappingProviderKeys = action(
+  (mappingProvider: DataSpaceMappingProvider, keys: string[]): void => {
+    mappingProvider.keys = keys;
+  },
+);
+
 export const dataSpace_setExecutionContextTestData = action(
   (
     executionContext: DataSpaceExecutionContext,

package/tsconfig.json

@@ -55,6 +55,7 @@
     "./src/__lib__/DSL_DataSpace_LegendStudioCodeSnippet.ts",
     "./src/__lib__/DSL_DataSpace_LegendStudioDocumentation.ts",
     "./src/stores/DataSpaceEditorState.ts",
+    "./src/stores/DataSpaceExecutableTemplateState.ts",
     "./src/stores/DataSpaceExecutionContextState.ts",
     "./src/stores/DataSpacePreviewState.ts",
     "./src/stores/DataSpaceTemplateQueryPromotionReviewerStore.ts",
@@ -63,16 +64,19 @@
     "./src/components/DSL_DataSpace_LegendStudioApplicationPlugin.tsx",
     "./src/components/DSL_NewDataProductEditor.tsx",
     "./src/components/DataSpaceEditor.tsx",
+    "./src/components/DataSpaceExecutableQueryAction.tsx",
     "./src/components/DataSpaceExecutionContextEditor.tsx",
     "./src/components/DataSpacePreviewAction.tsx",
     "./src/components/DataSpaceQueryAction.tsx",
     "./src/components/DataSpaceTemplateQueryPromoteReview.tsx",
-    "./src/components/DataSpaceGeneralEditor/DataSpaceDefaultExecutionContextSection.tsx",
     "./src/components/DataSpaceGeneralEditor/DataSpaceDiagramsSection.tsx",
     "./src/components/DataSpaceGeneralEditor/DataSpaceElementsSection.tsx",
     "./src/components/DataSpaceGeneralEditor/DataSpaceExecutablesSection.tsx",
     "./src/components/DataSpaceGeneralEditor/DataSpaceGeneralEditor.tsx",
-    "./src/components/DataSpaceGeneralEditor/DataSpaceSupportInfoSection.tsx"
+    "./src/components/DataSpaceGeneralEditor/DataSpaceHomeTab.tsx",
+    "./src/components/DataSpaceGeneralEditor/DataSpaceSidebar.tsx",
+    "./src/components/DataSpaceGeneralEditor/DataSpaceSupportInfoSection.tsx",
+    "./src/components/DataSpaceGeneralEditor/DataSpaceValidation.tsx"
   ],
   "include": [
     "src/**/*.ts",

package/lib/components/DataSpaceGeneralEditor/DataSpaceDefaultExecutionContextSection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataSpaceDefaultExecutionContextSection.d.ts","sourceRoot":"","sources":["../../../src/components/DataSpaceGeneralEditor/DataSpaceDefaultExecutionContextSection.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAgDH,eAAO,MAAM,uCAAuC;;CA0UlD,CAAC"}