@finos/legend-application-studio 28.21.4 → 28.21.6

package/src/stores/editor/EditorStore.ts

@@ -93,6 +93,7 @@ import {
   DEFAULT_TAB_SIZE,
 } from '@finos/legend-application';
 import { LEGEND_STUDIO_APP_EVENT } from '../../__lib__/LegendStudioEvent.js';
+import { LegendStudioUserDataHelper } from '../../__lib__/LegendStudioUserDataHelper.js';
 import type { EditorMode } from './EditorMode.js';
 import { StandardEditorMode } from './StandardEditorMode.js';
 import { WorkspaceUpdateConflictResolutionState } from './sidebar-state/WorkspaceUpdateConflictResolutionState.js';
@@ -691,6 +692,12 @@ export class EditorStore implements CommandRegistrar {
       }),
     );
     if (!this.sdlcState.currentProject) {
+      // The project the user navigated to doesn't exist (or isn't accessible).
+      // Drop it from the recents cache so we don't keep offering a dead link.
+      LegendStudioUserDataHelper.workspaceSetup_removeRecentProject(
+        this.applicationStore.userDataService,
+        projectId,
+      );
       // If the project is not found or the user does not have access to it,
       // we will not automatically redirect them to the setup page as they will lose the URL
       // instead, we give them the option to:
@@ -740,6 +747,15 @@ export class EditorStore implements CommandRegistrar {
       ),
     );
     if (!this.sdlcState.currentWorkspace) {
+      // The workspace the user navigated to doesn't exist anymore. Drop
+      // the matching entry from the recents cache (no-op for patch
+      // workspaces, which are never cached in the first place).
+      if (patchReleaseVersionId === undefined) {
+        LegendStudioUserDataHelper.workspaceSetup_removeRecentWorkspace(
+          this.applicationStore.userDataService,
+          { projectId, workspaceId, workspaceType },
+        );
+      }
       // If the workspace is not found,
       // we will not automatically redirect the user to the setup page as they will lose the URL
       // instead, we give them the option to:
@@ -810,6 +826,34 @@ export class EditorStore implements CommandRegistrar {
       onLeave(false);
       return;
     }
+    // At this point both the project and the workspace have been confirmed
+    // to exist on the server (the guards above bail out otherwise), so this
+    // is the authoritative "the user actually opened this workspace" moment.
+    // Record it in the recents cache so the workspace setup screen can offer
+    // it instantly next time.
+    // NOTE: patch-based workspaces are intentionally excluded from recents
+    // (they are not surfaced in the recents UI). Sandbox projects ARE
+    // included — opening one is still a meaningful "I worked here" signal,
+    // and surfacing it alongside other recents gives a faster one-click
+    // re-entry than waiting for the dedicated sandbox loader.
+    if (this.sdlcState.currentWorkspace.source === undefined) {
+      LegendStudioUserDataHelper.workspaceSetup_recordRecentProject(
+        this.applicationStore.userDataService,
+        {
+          projectId: this.sdlcState.currentProject.projectId,
+          name: this.sdlcState.currentProject.name,
+        },
+      );
+      LegendStudioUserDataHelper.workspaceSetup_recordRecentWorkspace(
+        this.applicationStore.userDataService,
+        {
+          projectId: this.sdlcState.currentProject.projectId,
+          workspaceId: this.sdlcState.currentWorkspace.workspaceId,
+          workspaceType: this.sdlcState.currentWorkspace.workspaceType,
+        },
+      );
+    }
+
     yield Promise.all([
       this.sdlcState.fetchCurrentRevision(
         projectId,

package/src/stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.ts

@@ -32,6 +32,10 @@ import {
 } from '@finos/legend-graph';
 import {
   ContentType,
+  csvDecodeValue,
+  csvEncodeValue,
+  csvStringify,
+  parseCSVContent,
   guaranteeNonEmptyString,
   tryToFormatLosslessJSONString,
   UnsupportedOperationError,
@@ -273,10 +277,16 @@ export class RelationElementState {
 
   updateRow(rowIndex: number, columnIndex: number, value: string): void {
     if (this.relationElement.rows[rowIndex]) {
-      this.relationElement.rows[rowIndex].values[columnIndex] = value;
+      this.relationElement.rows[rowIndex].values[columnIndex] =
+        csvEncodeValue(value);
     }
   }
 
+  getDisplayValue(rowIndex: number, columnIndex: number): string {
+    const value = this.relationElement.rows[rowIndex]?.values[columnIndex];
+    return value !== undefined ? csvDecodeValue(value) : '';
+  }
+
   clearAllData(): void {
     this.relationElement.rows.splice(0);
   }
@@ -285,7 +295,9 @@ export class RelationElementState {
     return JSON.stringify(
       {
         columns: this.relationElement.columns,
-        data: this.relationElement.rows,
+        data: this.relationElement.rows.map((row) => ({
+          values: row.values.map((v) => csvDecodeValue(v)),
+        })),
       },
       null,
       2,
@@ -310,7 +322,7 @@ export class RelationElementState {
     const insertStatements = this.relationElement.rows.map((row) => {
       const values = this.relationElement.columns
         .map((col, colIndex) => {
-          const value = row.values[colIndex] ?? '';
+          const value = csvDecodeValue(row.values[colIndex] ?? '');
           if (value !== '') {
             return `'${value.replace(/'/g, "''")}'`;
           }
@@ -324,64 +336,30 @@ export class RelationElementState {
   }
 
   exportCSV(): string {
-    const headers = this.relationElement.columns.map((col) => col);
-    const csvLines = [headers.join(',')];
-
-    this.relationElement.rows.forEach((row) => {
-      const values = headers.map((header, headerIndex) => {
-        const value = row.values[headerIndex] ?? '';
-        if (value.includes(',') || value.includes('"')) {
-          return `"${value.replace(/"/g, '""')}"`;
-        }
-        return value;
-      });
-      csvLines.push(values.join(','));
-    });
-
-    return csvLines.join('\n');
-  }
-
-  private parseCSVLine(line: string): string[] {
-    const result: string[] = [];
-    let current = '';
-    let inQuotes = false;
-
-    for (let i = 0; i < line.length; i++) {
-      const char = line[i];
-      if (char === '"') {
-        inQuotes = !inQuotes;
-      } else if (char === ',' && !inQuotes) {
-        result.push(current.trim());
-        current = '';
-      } else {
-        current += char;
-      }
-    }
-    result.push(current.trim());
-    return result;
+    // decode so that csvStringify does not double encode
+    const data = this.relationElement.rows.map((row) =>
+      row.values.map((v) => csvDecodeValue(v)),
+    );
+    return csvStringify([this.relationElement.columns, ...data]);
   }
 
   importCSV(csvContent: string): void {
-    const lines = csvContent.trim().split('\n');
-    if (lines.length === 0) {
+    const parsed = parseCSVContent(csvContent);
+    if (parsed.length === 0) {
       return;
     }
 
-    const firstLine = lines[0];
-    if (!firstLine) {
+    const headers = parsed[0];
+    if (!headers) {
       return;
     }
 
-    const headers = this.parseCSVLine(firstLine);
     this.relationElement.columns = headers;
-
-    this.relationElement.rows = lines.slice(1).map((line) => {
-      const values = this.parseCSVLine(line);
+    this.relationElement.rows = parsed.slice(1).map((values) => {
       const row = new RelationRowTestData();
-      row.values = [];
-      headers.forEach((header, index) => {
-        row.values[index] = values[index] ?? '';
-      });
+      row.values = headers.map((_, index) =>
+        csvEncodeValue(values[index] ?? ''),
+      );
       return observe_RelationRowTestData(row);
     });
   }

package/src/stores/editor/editor-state/element-editor-state/dataProduct/testable/DataProductTestableState.ts

@@ -26,6 +26,7 @@ import {
   LakehouseAccessPoint,
   DataProductTestSuite,
   BaseDataResolver,
+  ReferenceDataResolver,
   DataProductAccessPointTest,
   RelationElementsData,
   RelationElement,
@@ -34,11 +35,14 @@ import {
   TestError,
   TestExecutionStatus,
   EqualToRelation,
+  RelationRowTestData,
   observe_RelationElement,
+  observe_RelationRowTestData,
   observe_RelationElementsData,
   observe_DataProductTestSuite,
   IngestDefinition,
   getAccessorItemLabelForElement,
+  type AbstractPureGraphManager,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -59,7 +63,10 @@ import {
 } from 'mobx';
 import type { EditorStore } from '../../../../EditorStore.js';
 import type { DataProductEditorState } from '../DataProductEditorState.js';
-import { RelationElementState } from '../../data/EmbeddedDataState.js';
+import {
+  RelationElementsDataState,
+  RelationElementState,
+} from '../../data/EmbeddedDataState.js';
 import { TESTABLE_RESULT } from '../../../../sidebar-state/testable/GlobalTestRunnerState.js';
 import { testSuite_addTest } from '../../../../../graph-modifier/Testable_GraphModifierHelper.js';
 import {
@@ -71,10 +78,12 @@ const createEmptyRelationElement = (
   itemId: string,
   columns: string[] = [],
 ): RelationElement => {
+  const row = observe_RelationRowTestData(new RelationRowTestData());
+  row.values = columns.map(() => '');
   const relationElement = new RelationElement();
   relationElement.paths = [itemId];
   relationElement.columns = columns;
-  relationElement.rows = [];
+  relationElement.rows = [row];
   return observe_RelationElement(relationElement);
 };
 
@@ -123,6 +132,7 @@ interface ElementDataItem {
 
 const getElementDataItems = (
   element: PackageableElement,
+  graphManager: AbstractPureGraphManager,
 ): ElementDataItem[] => {
   if (element instanceof DataProduct) {
     return element.accessPointGroups
@@ -133,10 +143,12 @@ const getElementDataItems = (
       }));
   }
   if (element instanceof IngestDefinition) {
-    return (element.TEMPORARY_MATVIEW_FUNCTION_DATA_SETS ?? []).map((ds) => ({
-      id: ds.name,
-      label: ds.name,
-    }));
+    return graphManager
+      .getIngestDefinitionDatasetNames(element)
+      .map((name) => ({
+        id: name,
+        label: name,
+      }));
   }
   return [];
 };
@@ -252,31 +264,21 @@ export class DataProductElementTestDataState {
   readonly testDataState: DataProductTestDataState;
   readonly testData: BaseDataResolver;
   readonly editorStore: EditorStore;
-
-  /** Currently selected dataset/item within this element's RelationElementsData */
-  selectedItemId: string | undefined;
-  /** RelationElementState for the currently selected item */
-  relationElementState: RelationElementState | undefined;
+  readonly relationElementsDataState: RelationElementsDataState | undefined;
 
   constructor(
     testDataState: DataProductTestDataState,
     testData: BaseDataResolver,
   ) {
-    makeObservable(this, {
-      selectedItemId: observable,
-      relationElementState: observable,
-      setSelectedItem: action,
-    });
     this.testDataState = testDataState;
     this.testData = testData;
     this.editorStore = testDataState.editorStore;
-    // Select the first item that has data
     if (testData.data instanceof RelationElementsData) {
-      const firstRel = testData.data.relationElements[0];
-      if (firstRel) {
-        this.selectedItemId = firstRel.paths[0];
-        this.relationElementState = new RelationElementState(firstRel);
-      }
+      this.relationElementsDataState = new RelationElementsDataState(
+        this.editorStore,
+        testData.data,
+      );
+      this.initAccessorOptions();
     }
   }
 
@@ -292,35 +294,81 @@ export class DataProductElementTestDataState {
     return getAccessorItemLabelForElement(this.element as AccessorOwner);
   }
 
-  get configuredItemIds(): string[] {
-    if (this.testData.data instanceof RelationElementsData) {
-      return this.testData.data.relationElements.map((re) => re.paths[0] ?? '');
+  private initAccessorOptions(): void {
+    const dataState = this.relationElementsDataState;
+    if (!dataState) {
+      return;
     }
-    return [];
-  }
-
-  get configuredItems(): ElementDataItem[] {
-    const availableItemsById = new Map(
-      getElementDataItems(this.element).map((item) => [item.id, item.label]),
+    this.refreshAccessorOptions(dataState).catch(noop);
+    dataState.setRefreshAccessorOptions(() =>
+      this.refreshAccessorOptions(dataState),
     );
-    return this.configuredItemIds.map((id) => ({
-      id,
-      label: availableItemsById.get(id) ?? id,
-    }));
   }
 
-  setSelectedItem(itemId: string | undefined): void {
-    this.selectedItemId = itemId;
-    if (itemId && this.testData.data instanceof RelationElementsData) {
-      const relEl = this.testData.data.relationElements.find(
-        (re) => re.paths[0] === itemId,
-      );
-      this.relationElementState = relEl
-        ? new RelationElementState(relEl)
-        : undefined;
-    } else {
-      this.relationElementState = undefined;
+  private async refreshAccessorOptions(
+    dataState: RelationElementsDataState,
+  ): Promise<void> {
+    const element = this.element;
+    const graphManager = this.editorStore.graphManagerState.graphManager;
+    const graph = this.editorStore.graphManagerState.graph;
+    const items = getElementDataItems(element, graphManager);
+    if (items.length === 0) {
+      dataState.setAccessorOptions(undefined, undefined);
+      return;
     }
+    const typeLabel = this.itemLabel;
+    const options = await Promise.all(
+      items.map(async (item) => {
+        let columns: string[] = [];
+        try {
+          if (element instanceof IngestDefinition) {
+            const accessor = graphManager.createAccessorFromPackageableElement(
+              element,
+              graph,
+              { schemaName: undefined, tableName: item.id },
+            );
+            if (accessor) {
+              columns = accessor.relationType.columns.map((c) => c.name);
+            }
+          } else if (element instanceof DataProduct) {
+            const accessor = await graphManager.buildDataProductAccessor(
+              element,
+              graph,
+              { tableName: item.id },
+            );
+            if (accessor) {
+              columns = accessor.relationType.columns.map((c) => c.name);
+            }
+          }
+        } catch {
+          // best-effort column resolution
+        }
+        return {
+          label: item.label,
+          value: item.id,
+          columns,
+        };
+      }),
+    );
+    runInAction(() => {
+      dataState.setAccessorOptions(options, typeLabel);
+      // Back-fill columns on existing relation elements that have none
+      const columnsByItem = new Map(
+        options
+          .filter((o) => o.columns.length > 0)
+          .map((o) => [o.value, o.columns]),
+      );
+      for (const relState of dataState.relationElementStates) {
+        const rel = relState.relationElement;
+        if (rel.columns.length === 0) {
+          const key = rel.paths[rel.paths.length - 1];
+          const cols = key ? columnsByItem.get(key) : undefined;
+          if (cols) {
+            rel.columns = cols;
+          }
+        }
+      }
+    });
   }
 }
 
@@ -332,6 +380,7 @@ export class DataProductTestDataState {
 
   elementTestDataStates: DataProductElementTestDataState[] = [];
   selectedElementTestDataState: DataProductElementTestDataState | undefined;
+  showAddElementModal = false;
 
   constructor(
     suiteState: DataProductTestSuiteState,
@@ -343,7 +392,11 @@ export class DataProductTestDataState {
     makeObservable(this, {
       elementTestDataStates: observable,
       selectedElementTestDataState: observable,
+      showAddElementModal: observable,
       setSelectedElementTestDataState: action,
+      setShowAddElementModal: action,
+      addElement: action,
+      deleteElement: action,
       refreshElementTestDataStates: action,
     });
     this.editorStore = suiteState.editorStore;
@@ -351,16 +404,64 @@ export class DataProductTestDataState {
     this.refreshElementTestDataStates(options);
   }
 
+  get availableElementsToAdd(): PackageableElement[] {
+    const suite = this.suiteState.suite;
+    const existingPaths = new Set(
+      (suite.testData ?? [])
+        .filter(
+          (td): td is BaseDataResolver | ReferenceDataResolver =>
+            td instanceof BaseDataResolver ||
+            td instanceof ReferenceDataResolver,
+        )
+        .map((td) => td.element.value.path),
+    );
+    const graph = this.editorStore.graphManagerState.graph;
+    const currentDpPath = this.suiteState.testableState.dataProduct.path;
+    const candidates: PackageableElement[] = [
+      ...graph.ingests,
+      ...graph.allElements.filter(
+        (e) => e instanceof DataProduct && e.path !== currentDpPath,
+      ),
+    ];
+    return candidates.filter((e) => !existingPaths.has(e.path));
+  }
+
+  setShowAddElementModal(val: boolean): void {
+    this.showAddElementModal = val;
+  }
+
+  addElement(path: string): void {
+    const element =
+      this.editorStore.graphManagerState.graph.getNullableElement(path);
+    if (!element) {
+      return;
+    }
+    const resolver = new BaseDataResolver();
+    resolver.element = PackageableElementExplicitReference.create(element);
+    const relData = new RelationElementsData();
+    relData.relationElements = [];
+    observe_RelationElementsData(relData);
+    resolver.data = relData;
+    const suite = this.suiteState.suite;
+    suite.testData = [...(suite.testData ?? []), resolver];
+    this.refreshElementTestDataStates({ selectedElementPath: path });
+  }
+
+  deleteElement(elementState: DataProductElementTestDataState): void {
+    const suite = this.suiteState.suite;
+    if (suite.testData) {
+      const idx = suite.testData.indexOf(elementState.testData);
+      suite.testData.splice(idx, 1);
+    }
+    this.refreshElementTestDataStates();
+  }
+
   refreshElementTestDataStates(options?: {
     selectedElementPath?: string | undefined;
-    selectedItemId?: string | undefined;
   }): void {
     const previouslySelectedElementPath =
       options?.selectedElementPath ??
       this.selectedElementTestDataState?.element.path;
-    const previouslySelectedItemId =
-      options?.selectedItemId ??
-      this.selectedElementTestDataState?.selectedItemId;
     const suite = this.suiteState.suite;
     this.elementTestDataStates = (suite.testData ?? [])
       .filter((td): td is BaseDataResolver => td instanceof BaseDataResolver)
@@ -370,14 +471,6 @@ export class DataProductTestDataState {
       this.elementTestDataStates.find(
         (state) => state.element.path === previouslySelectedElementPath,
       ) ?? this.elementTestDataStates[0];
-
-    if (this.selectedElementTestDataState && previouslySelectedItemId) {
-      const nextSelectedItemId =
-        this.selectedElementTestDataState.configuredItemIds.find(
-          (itemId) => itemId === previouslySelectedItemId,
-        ) ?? this.selectedElementTestDataState.configuredItemIds[0];
-      this.selectedElementTestDataState.setSelectedItem(nextSelectedItemId);
-    }
   }
 
   setSelectedElementTestDataState(
@@ -427,8 +520,6 @@ export class DataProductTestSuiteState extends TestableTestSuiteEditorState {
     this.testDataState = new DataProductTestDataState(this, {
       selectedElementPath:
         this.testDataState.selectedElementTestDataState?.element.path,
-      selectedItemId:
-        this.testDataState.selectedElementTestDataState?.selectedItemId,
     });
   }
 
@@ -540,42 +631,19 @@ export class DataProductTestSuiteState extends TestableTestSuiteEditorState {
         }
       }
     } else {
-      // Fallback: single resolver on current DP
-      let relationData = this.suite.testData?.find(
-        (td): td is BaseDataResolver =>
-          td instanceof BaseDataResolver &&
-          td.element.value === this.testableState.dataProduct &&
-          td.data instanceof RelationElementsData,
-      )?.data as RelationElementsData | undefined;
-
-      if (!relationData) {
-        const testData = new BaseDataResolver();
-        testData.element = PackageableElementExplicitReference.create(
-          this.testableState.dataProduct,
-        );
-        relationData = new RelationElementsData();
-        relationData.relationElements = [];
-        observe_RelationElementsData(relationData);
-        testData.data = relationData;
-        this.suite.testData = [...(this.suite.testData ?? []), testData];
-      }
-      if (
-        !relationData.relationElements.find(
-          (re) => re.paths[0] === accessPointId,
-        )
-      ) {
-        relationData.relationElements.push(
-          createEmptyRelationElement(accessPointId, inferredColumns),
-        );
-      }
+      this.editorStore.applicationStore.notificationService.notifyWarning(
+        'Access Point accessors cannot be resolved',
+      );
     }
 
     const assertion = new EqualToRelation();
     assertion.id = 'assert_1';
     const expectedRelElement = new RelationElement();
+    const expectedRow = observe_RelationRowTestData(new RelationRowTestData());
+    expectedRow.values = inferredColumns.map(() => '');
     expectedRelElement.paths = [accessPointId];
     expectedRelElement.columns = inferredColumns;
-    expectedRelElement.rows = [];
+    expectedRelElement.rows = [expectedRow];
     observe_RelationElement(expectedRelElement);
     assertion.expected = expectedRelElement;
     test.assertions = [assertion];
@@ -792,17 +860,11 @@ export class DataProductTestableState {
         suite.testData.push(resolver);
       }
     }
-    // Fallback: no external sources resolved — seed a single resolver on current DP
+    // If no external sources were resolved, notify the user and leave test data empty
     if (suite.testData.length === 0) {
-      const testData = new BaseDataResolver();
-      testData.element = PackageableElementExplicitReference.create(dp);
-      const relData = new RelationElementsData();
-      relData.relationElements = [
-        createEmptyRelationElement(accessPointId, inferredColumns),
-      ];
-      observe_RelationElementsData(relData);
-      testData.data = relData;
-      suite.testData = [testData];
+      this.editorStore.applicationStore.notificationService.notifyWarning(
+        'Access Point accessors cannot be resolved',
+      );
     }
 
     // Create one initial test with EqualToRelation assertion
@@ -814,9 +876,11 @@ export class DataProductTestableState {
     const assertion = new EqualToRelation();
     assertion.id = 'assert_1';
     const expectedRelElement = new RelationElement();
+    const expectedRow = observe_RelationRowTestData(new RelationRowTestData());
+    expectedRow.values = inferredColumns.map(() => '');
     expectedRelElement.paths = [accessPointId];
     expectedRelElement.columns = inferredColumns;
-    expectedRelElement.rows = [];
+    expectedRelElement.rows = [expectedRow];
     observe_RelationElement(expectedRelElement);
     assertion.expected = expectedRelElement;
     test.assertions = [assertion];