@finos/legend-extension-dsl-data-space-studio 0.1.152 → 0.1.154

package/src/stores/DataSpaceExecutionContextState.ts

@@ -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 type { EditorStore } from '@finos/legend-application-studio';
+import { action, makeObservable, observable } from 'mobx';
+import type { DataSpaceEditorState } from './DataSpaceEditorState.js';
+import {
+  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,
+      addExecutionContext: action,
+      removeExecutionContext: action,
+      renameExecutionContext: action,
+      setSelectedExecutionContext: action,
+      setExecutionContextToRename: action,
+      setNewExecutionContextModal: action,
+    });
+    this.executionContexts = dataSpaceEditorState.dataSpace.executionContexts;
+    this.selectedExecutionContext =
+      dataSpaceEditorState.dataSpace.executionContexts[0];
+    this.dataSpaceEditorState = dataSpaceEditorState;
+    this.editorStore = dataSpaceEditorState.editorStore;
+  }
+
+  get dataSpace(): DataSpace {
+    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;
+  }
+
+  removeExecutionContext(
+    dataSpaceExecutionContext: DataSpaceExecutionContext,
+  ): void {
+    dataSpace_removeExecutionContext(this.dataSpace, dataSpaceExecutionContext);
+  }
+
+  renameExecutionContext(
+    dataSpaceExecutionContext: DataSpaceExecutionContext,
+    newName: string,
+  ): void {
+    dataSpace_setExecutionContextName(dataSpaceExecutionContext, newName);
+  }
+
+  setSelectedExecutionContext(val: DataSpaceExecutionContext): void {
+    this.selectedExecutionContext = val;
+  }
+
+  setExecutionContextToRename(
+    val: DataSpaceExecutionContext | undefined,
+  ): void {
+    this.executionContextToRename = 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

@@ -15,16 +15,291 @@
  */
 
 import { action } from 'mobx';
-import type { DataSpace } from '@finos/legend-extension-dsl-data-space/graph';
+import {
+  type DataSpace,
+  type DataSpaceDiagram,
+  type DataSpaceElementPointer,
+  type DataSpaceExecutable,
+  type DataSpaceExecutionContext,
+  type DataSpaceSupportCombinedInfo,
+  type DataSpaceSupportEmail,
+  type DataSpaceSupportInfo,
+  observe_DataSpaceDiagram,
+  observe_DataSpaceElementPointer,
+  observe_DataSpaceExecutionContext,
+  observe_DataSpaceSupportInfo,
+} from '@finos/legend-extension-dsl-data-space/graph';
+import type {
+  PackageableElementReference,
+  Mapping,
+  PackageableRuntime,
+  DataElementReference,
+} from '@finos/legend-graph';
+import { addUniqueEntry } from '@finos/legend-shared';
 
-export const set_title = action(
+// Basic properties
+export const dataSpace_setTitle = action(
   (dataSpace: DataSpace, type: string | undefined): void => {
     dataSpace.title = type;
   },
 );
 
-export const set_description = action(
+export const dataSpace_setDescription = action(
   (dataSpace: DataSpace, content: string | undefined): void => {
     dataSpace.description = content;
   },
 );
+
+// Array properties
+export const dataSpace_setExecutionContexts = action(
+  (
+    dataSpace: DataSpace,
+    executionContexts: DataSpaceExecutionContext[],
+  ): void => {
+    dataSpace.executionContexts = executionContexts;
+  },
+);
+
+export const dataSpace_setDefaultExecutionContext = action(
+  (
+    dataSpace: DataSpace,
+    defaultExecutionContext: DataSpaceExecutionContext,
+  ): void => {
+    dataSpace.defaultExecutionContext = defaultExecutionContext;
+  },
+);
+
+export const dataSpace_setElements = action(
+  (
+    dataSpace: DataSpace,
+    elements: DataSpaceElementPointer[] | undefined,
+  ): void => {
+    dataSpace.elements = elements;
+  },
+);
+
+export const dataSpace_setExecutables = action(
+  (
+    dataSpace: DataSpace,
+    executables: DataSpaceExecutable[] | undefined,
+  ): void => {
+    dataSpace.executables = executables;
+  },
+);
+
+export const dataSpace_setDiagrams = action(
+  (dataSpace: DataSpace, diagrams: DataSpaceDiagram[] | undefined): void => {
+    dataSpace.diagrams = diagrams;
+  },
+);
+
+export const dataSpace_setSupportInfo = action(
+  (
+    dataSpace: DataSpace,
+    supportInfo: DataSpaceSupportInfo | undefined,
+  ): void => {
+    dataSpace.supportInfo =
+      supportInfo !== undefined
+        ? observe_DataSpaceSupportInfo(supportInfo)
+        : undefined;
+  },
+);
+
+// Array item management
+export const dataSpace_addExecutionContext = action(
+  (dataSpace: DataSpace, executionContext: DataSpaceExecutionContext): void => {
+    addUniqueEntry(
+      dataSpace.executionContexts,
+      observe_DataSpaceExecutionContext(executionContext),
+    );
+  },
+);
+
+export const dataSpace_removeExecutionContext = action(
+  (
+    dataSpace: DataSpace,
+    dataSpaceExecutionContext: DataSpaceExecutionContext,
+  ): void => {
+    const index = dataSpace.executionContexts.indexOf(
+      dataSpaceExecutionContext,
+    );
+    dataSpace.executionContexts.splice(index, 1);
+  },
+);
+
+export const dataSpace_addElement = action(
+  (dataSpace: DataSpace, element: DataSpaceElementPointer): void => {
+    if (!dataSpace.elements) {
+      dataSpace.elements = [];
+    }
+    addUniqueEntry(
+      dataSpace.elements,
+      observe_DataSpaceElementPointer(element),
+    );
+  },
+);
+
+export const dataSpace_removeElement = action(
+  (dataSpace: DataSpace, element: DataSpaceElementPointer): void => {
+    if (dataSpace.elements) {
+      const index = dataSpace.elements.indexOf(element);
+      dataSpace.elements.splice(index, 1);
+    }
+  },
+);
+
+export const dataSpace_setElementExclude = action(
+  (element: DataSpaceElementPointer, exclude: boolean): void => {
+    element.exclude = exclude;
+  },
+);
+
+export const dataSpace_addExecutable = action(
+  (dataSpace: DataSpace, executable: DataSpaceExecutable): void => {
+    if (!dataSpace.executables) {
+      dataSpace.executables = [];
+    }
+    dataSpace.executables.push(executable);
+  },
+);
+
+export const dataSpace_removeExecutable = action(
+  (dataSpace: DataSpace, executable: DataSpaceExecutable): void => {
+    if (dataSpace.executables) {
+      const index = dataSpace.executables.indexOf(executable);
+      dataSpace.executables.splice(index, 1);
+    }
+  },
+);
+
+export const dataSpace_addDiagram = action(
+  (dataSpace: DataSpace, diagram: DataSpaceDiagram): void => {
+    if (!dataSpace.diagrams) {
+      dataSpace.diagrams = [];
+    }
+    dataSpace.diagrams.push(observe_DataSpaceDiagram(diagram));
+  },
+);
+
+export const dataSpace_removeDiagram = action(
+  (dataSpace: DataSpace, diagram: DataSpaceDiagram): void => {
+    if (dataSpace.diagrams) {
+      const index = dataSpace.diagrams.indexOf(diagram);
+      if (index !== -1) {
+        dataSpace.diagrams.splice(index, 1);
+      }
+    }
+  },
+);
+
+export const dataSpace_setDiagramTitle = action(
+  (diagram: DataSpaceDiagram, title: string): void => {
+    diagram.title = title;
+  },
+);
+
+export const dataSpace_setDiagramDescription = action(
+  (diagram: DataSpaceDiagram, description: string | undefined): void => {
+    diagram.description = description;
+  },
+);
+
+// Nested object properties
+export const dataSpace_setExecutionContextName = action(
+  (executionContext: DataSpaceExecutionContext, name: string): void => {
+    executionContext.name = name;
+  },
+);
+
+export const dataSpace_setExecutionContextTitle = action(
+  (
+    executionContext: DataSpaceExecutionContext,
+    title: string | undefined,
+  ): void => {
+    executionContext.title = title;
+  },
+);
+
+export const dataSpace_setExecutionContextDescription = action(
+  (
+    executionContext: DataSpaceExecutionContext,
+    description: string | undefined,
+  ): void => {
+    executionContext.description = description;
+  },
+);
+
+export const dataSpace_setExecutionContextMapping = action(
+  (
+    executionContext: DataSpaceExecutionContext,
+    mapping: PackageableElementReference<Mapping>,
+  ): void => {
+    executionContext.mapping = mapping;
+  },
+);
+
+export const dataSpace_setExecutionContextDefaultRuntime = action(
+  (
+    executionContext: DataSpaceExecutionContext,
+    defaultRuntime: PackageableElementReference<PackageableRuntime>,
+  ): void => {
+    executionContext.defaultRuntime = defaultRuntime;
+  },
+);
+
+export const dataSpace_setExecutionContextTestData = action(
+  (
+    executionContext: DataSpaceExecutionContext,
+    testData: DataElementReference | undefined,
+  ): void => {
+    executionContext.testData = testData;
+  },
+);
+
+export const dataSpace_setDocumentationUrl = action(
+  (supportInfo: DataSpaceSupportInfo, url: string): void => {
+    supportInfo.documentationUrl = url;
+  },
+);
+
+export const dataSpace_email_setSupportInfoEmail = action(
+  (supportInfo: DataSpaceSupportEmail, email: string): void => {
+    supportInfo.address = email;
+  },
+);
+
+export const dataSpace_combined_addEmail = action(
+  (supportInfo: DataSpaceSupportCombinedInfo, email: string): void => {
+    if (supportInfo.emails === undefined) {
+      supportInfo.emails = [];
+    }
+    addUniqueEntry(supportInfo.emails, email);
+  },
+);
+
+export const dataSpace_combined_deleteEmail = action(
+  (supportInfo: DataSpaceSupportCombinedInfo, email: string): void => {
+    const index = supportInfo.emails?.indexOf(email);
+    if (index !== undefined && index !== -1) {
+      supportInfo.emails?.splice(index, 1);
+    }
+  },
+);
+
+export const dataSpace_combined_setWebsite = action(
+  (supportInfo: DataSpaceSupportCombinedInfo, website: string): void => {
+    supportInfo.website = website;
+  },
+);
+
+export const dataSpace_combined_setFaqUrl = action(
+  (supportInfo: DataSpaceSupportCombinedInfo, faqUrl: string): void => {
+    supportInfo.faqUrl = faqUrl;
+  },
+);
+
+export const dataSpace_combined_setSupportUrl = action(
+  (supportInfo: DataSpaceSupportCombinedInfo, supportUrl: string): void => {
+    supportInfo.supportUrl = supportUrl;
+  },
+);

package/tsconfig.json

@@ -55,14 +55,24 @@
     "./src/__lib__/DSL_DataSpace_LegendStudioCodeSnippet.ts",
     "./src/__lib__/DSL_DataSpace_LegendStudioDocumentation.ts",
     "./src/stores/DataSpaceEditorState.ts",
+    "./src/stores/DataSpaceExecutionContextState.ts",
     "./src/stores/DataSpacePreviewState.ts",
     "./src/stores/DataSpaceTemplateQueryPromotionReviewerStore.ts",
     "./src/stores/studio/DSL_DataSpace_GraphModifierHelper.ts",
+    "./src/components/DSL_DataProduct_ElementDriver.tsx",
     "./src/components/DSL_DataSpace_LegendStudioApplicationPlugin.tsx",
+    "./src/components/DSL_NewDataProductEditor.tsx",
     "./src/components/DataSpaceEditor.tsx",
+    "./src/components/DataSpaceExecutionContextEditor.tsx",
     "./src/components/DataSpacePreviewAction.tsx",
     "./src/components/DataSpaceQueryAction.tsx",
-    "./src/components/DataSpaceTemplateQueryPromoteReview.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"
   ],
   "include": [
     "src/**/*.ts",