@finos/legend-application-studio 28.21.6 → 28.21.8

package/src/components/editor/editor-group/dataProduct/DataProductEditor.tsx

@@ -847,7 +847,7 @@ export const LakehouseDataProductAccessPointEditor = observer(
                 applicationStore.config.options.queryBuilderConfig,
                 editorStore.editorMode.getSourceInfo(),
               );
-              queryBuilderState.changeAccessorOwner(ingestDefinition);
+              await queryBuilderState.changeAccessorOwner(ingestDefinition);
               const compatibleRuntimes = getCompatibleRuntimesFromAccessorOwner(
                 ingestDefinition,
                 editorStore.graphManagerState,
@@ -2232,9 +2232,6 @@ const AccessPointGroupTab = observer(
 const DataProductSidebar = observer(
   (props: { dataProductEditorState: DataProductEditorState }) => {
     const { dataProductEditorState } = props;
-    const showTestingTab =
-      dataProductEditorState.editorStore.applicationStore.config.options
-        .NonProductionFeatureFlag;
     const sidebarTabs = [
       {
         label: DATA_PRODUCT_TAB.HOME,
@@ -2250,15 +2247,11 @@ const DataProductSidebar = observer(
         title: 'Operational Metadata',
         icon: <GearSuggestIcon />,
       },
-      ...(showTestingTab
-        ? [
-            {
-              label: DATA_PRODUCT_TAB.TESTING,
-              title: 'Testing',
-              icon: <FlaskIcon />,
-            },
-          ]
-        : []),
+      {
+        label: DATA_PRODUCT_TAB.TESTING,
+        title: 'Testing',
+        icon: <FlaskIcon />,
+      },
       {
         label: DATA_PRODUCT_TAB.SUPPORT,
         icon: <QuestionCircleIcon />,
@@ -3367,8 +3360,6 @@ export const DataProductEditor = observer(() => {
   const [showPreview, setShowPreview] = useState(false);
   const [dataProductViewerState, setDataProductViewerState] =
     useState<DataProductViewerState>();
-  const showTestingTab =
-    editorStore.applicationStore.config.options.NonProductionFeatureFlag;
 
   const selectedActivity = dataProductEditorState.selectedTab;
   const renderActivivtyBarTab = (): React.ReactNode => {
@@ -3402,12 +3393,12 @@ export const DataProductEditor = observer(() => {
           />
         );
       case DATA_PRODUCT_TAB.TESTING:
-        return showTestingTab ? (
+        return (
           <DataProductTestableEditor
             dataProductEditorState={dataProductEditorState}
             isReadOnly={isReadOnly}
           />
-        ) : null;
+        );
       default:
         return null;
     }
@@ -3423,15 +3414,6 @@ export const DataProductEditor = observer(() => {
     );
   }, [dataProductEditorState]);
 
-  useEffect(() => {
-    if (
-      !showTestingTab &&
-      dataProductEditorState.selectedTab === DATA_PRODUCT_TAB.TESTING
-    ) {
-      dataProductEditorState.setSelectedTab(DATA_PRODUCT_TAB.HOME);
-    }
-  }, [dataProductEditorState, showTestingTab]);
-
   useEffect(
     () =>
       autorun(

package/src/components/workspace-setup/RecentWorkspacesPanel.tsx

@@ -65,15 +65,15 @@ export const RecentWorkspacesPanel = observer(
     const applicationStore = setupStore.applicationStore;
 
     // Recents are stored in LRU order (most-recent first). Show the top N
-    // workspaces; map each to its project name (or fall back to projectId
-    // if the matching project entry was evicted independently).
+    // workspaces; look up each one's cached project entry for richer tile
+    // metadata (name, description tooltip, tag badges).
     const tiles = setupStore.recentWorkspaces.slice(0, MAX_TILES);
     if (tiles.length === 0) {
       return null;
     }
 
-    const projectNameById = new Map(
-      setupStore.recentProjects.map((p) => [p.projectId, p.name]),
+    const projectById = new Map(
+      setupStore.recentProjects.map((p) => [p.projectId, p]),
     );
 
     const openWorkspace = (
@@ -96,8 +96,14 @@ export const RecentWorkspacesPanel = observer(
         </div>
         <div className="workspace-setup__recents__grid">
           {tiles.map((entry) => {
-            const projectName =
-              projectNameById.get(entry.projectId) ?? entry.projectId;
+            const cachedProject = projectById.get(entry.projectId);
+            const projectName = cachedProject?.name ?? entry.projectId;
+            const projectDescription = cachedProject?.description ?? '';
+            const projectTags = cachedProject?.tags ?? [];
+            const tileTitle =
+              projectDescription.trim().length > 0
+                ? `${projectName} / ${entry.workspaceId}\n${projectDescription}`
+                : `Open ${projectName} / ${entry.workspaceId}`;
             const key = `${entry.projectId}::${entry.workspaceType}::${entry.workspaceId}`;
             const handleRemove = (
               event: React.MouseEvent<HTMLButtonElement>,
@@ -114,7 +120,7 @@ export const RecentWorkspacesPanel = observer(
                 key={key}
                 type="button"
                 className="workspace-setup__recents__tile"
-                title={`Open ${projectName} / ${entry.workspaceId}`}
+                title={tileTitle}
                 onClick={() =>
                   openWorkspace(
                     entry.projectId,
@@ -148,8 +154,22 @@ export const RecentWorkspacesPanel = observer(
                     {entry.workspaceId}
                   </span>
                 </div>
-                <div className="workspace-setup__recents__tile__time">
-                  {formatRelativeTime(entry.lastOpenedAt)}
+                <div className="workspace-setup__recents__tile__meta">
+                  {projectTags.length > 0 && (
+                    <div className="workspace-setup__recents__tile__tags">
+                      {projectTags.slice(0, 2).map((tag) => (
+                        <span
+                          key={tag}
+                          className="workspace-setup__recents__tile__tag"
+                        >
+                          {tag}
+                        </span>
+                      ))}
+                    </div>
+                  )}
+                  <div className="workspace-setup__recents__tile__time">
+                    {formatRelativeTime(entry.lastOpenedAt)}
+                  </div>
                 </div>
               </button>
             );

package/src/components/workspace-setup/WorkspaceSetup.tsx

@@ -378,15 +378,14 @@ export const WorkspaceSetup = withWorkspaceSetupStore(
     const recentProjectOptions: ProjectOption[] = setupStore.recentProjects
       .filter((r) => !loadedProjectIds.has(r.projectId))
       .map((r) => {
-        // Construct a lightweight Project stand-in so the existing selector
-        // contract is preserved. The full project will be fetched on click
-        // via `selectRecentProject`.
+        // Rebuild a real Project from the cached metadata; no synthetic
+        // fields needed since we persist everything the schema requires.
         const stub = Project.serialization.fromJson({
           projectId: r.projectId,
           name: r.name,
-          description: '',
-          webUrl: '',
-          tags: [],
+          description: r.description,
+          webUrl: r.webUrl,
+          tags: r.tags,
         } as PlainObject<Project>);
         return { label: stub.name, value: stub };
       });

package/src/stores/editor/EditorStore.ts

@@ -842,6 +842,9 @@ export class EditorStore implements CommandRegistrar {
         {
           projectId: this.sdlcState.currentProject.projectId,
           name: this.sdlcState.currentProject.name,
+          description: this.sdlcState.currentProject.description,
+          webUrl: this.sdlcState.currentProject.webUrl,
+          tags: this.sdlcState.currentProject.tags,
         },
       );
       LegendStudioUserDataHelper.workspaceSetup_recordRecentWorkspace(

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

@@ -322,11 +322,12 @@ export class DataProductElementTestDataState {
         let columns: string[] = [];
         try {
           if (element instanceof IngestDefinition) {
-            const accessor = graphManager.createAccessorFromPackageableElement(
-              element,
-              graph,
-              { schemaName: undefined, tableName: item.id },
-            );
+            const accessor =
+              await graphManager.createAccessorFromPackageableElement(
+                element,
+                graph,
+                { schemaName: undefined, tableName: item.id },
+              );
             if (accessor) {
               columns = accessor.relationType.columns.map((c) => c.name);
             }

package/src/stores/workspace-setup/WorkspaceSetupStore.ts

@@ -93,7 +93,6 @@ export class WorkspaceSetupStore {
   loadWorkspacesState = ActionState.create();
   createWorkspaceState = ActionState.create();
   showCreateWorkspaceModal = false;
-  showAdvancedWorkspaceFilterOptions = false;
 
   graphManagerState: GraphManagerState;
 
@@ -115,7 +114,6 @@ export class WorkspaceSetupStore {
       showCreateProjectModal: observable,
       workspaces: observable,
       currentWorkspace: observable,
-      showAdvancedWorkspaceFilterOptions: observable,
       loadSandboxState: observable,
       showCreateWorkspaceModal: observable,
       sandboxProject: observable,
@@ -128,7 +126,6 @@ export class WorkspaceSetupStore {
       recentWorkspaces: observable,
       setShowCreateProjectModal: action,
       setShowCreateWorkspaceModal: action,
-      setShowAdvancedWorkspaceFilterOptions: action,
       setImportProjectSuccessReport: action,
       setSandboxModal: action,
       changeWorkspace: action,
@@ -183,10 +180,6 @@ export class WorkspaceSetupStore {
     this.showCreateWorkspaceModal = val;
   }
 
-  setShowAdvancedWorkspaceFilterOptions(val: boolean): void {
-    this.showAdvancedWorkspaceFilterOptions = val;
-  }
-
   setImportProjectSuccessReport(
     importProjectSuccessReport: ImportProjectSuccessReport | undefined,
   ): void {
@@ -262,6 +255,12 @@ export class WorkspaceSetupStore {
    * Fetches a project by id (used when the user picks a cached "recent"
    * project that may not be in the current search results) and switches to
    * it. If the project no longer exists, the entry is pruned from recents.
+   *
+   * NOTE: we deliberately don't short-circuit using the cached recent entry
+   * here. Going through `getProject` keeps the prune-on-404 path intact, and
+   * the cached metadata is already used elsewhere to make the UI feel fast
+   * (dropdown stubs in `WorkspaceSetup.tsx` and tile labels in
+   * `RecentWorkspacesPanel.tsx`).
    */
   *selectRecentProject(projectId: string): GeneratorFn<void> {
     this.selectRecentProjectState.inProgress();
@@ -304,6 +303,12 @@ export class WorkspaceSetupStore {
         message: `Sandbox project ${sandboxProject.projectId} created. Creating default workspace...`,
         showLoading: true,
       });
+      // Invalidate the cached sandbox info so loadSandboxProject re-fetches
+      // and persists the newly-created project id instead of reusing the
+      // stale "no sandbox yet" cache entry.
+      LegendStudioUserDataHelper.workspaceSetup_clearSandboxInfo(
+        this.applicationStore.userDataService,
+      );
       yield flowResult(this.loadSandboxProject());
       const sandbox = guaranteeType(
         this.sandboxProject,
@@ -460,10 +465,58 @@ export class WorkspaceSetupStore {
       if (this.enginePromise) {
         yield this.enginePromise;
       }
+
+      const userId = this.sdlcServerClient.currentUser?.userId;
+
+      // Fast path — if we have a recent, user-matching cache entry, use it to
+      // avoid the `userHasPrototypeProjectAccess` graph manager call and the
+      // sandbox-tag project search. We still hit SDLC once to confirm the
+      // cached projectId is alive, but `getProject(id)` is cheaper than the
+      // tagged search and self-invalidates on 404.
+      if (userId) {
+        const cached =
+          LegendStudioUserDataHelper.workspaceSetup_getCachedSandboxInfo(
+            this.applicationStore.userDataService,
+            userId,
+          );
+        if (cached) {
+          this.hasSandboxAccess = cached.hasAccess;
+          if (!cached.hasAccess) {
+            // No access, no project — nothing else to do.
+            this.sandboxProject = true;
+            this.loadSandboxState.pass();
+            return;
+          }
+          if (cached.projectId) {
+            try {
+              this.sandboxProject = Project.serialization.fromJson(
+                (yield this.sdlcServerClient.getProject(
+                  cached.projectId,
+                )) as PlainObject<Project>,
+              );
+              this.loadSandboxState.pass();
+              return;
+            } catch {
+              // Cached sandbox project no longer exists on the server; drop
+              // the cache and fall through to the full refresh.
+              LegendStudioUserDataHelper.workspaceSetup_clearSandboxInfo(
+                this.applicationStore.userDataService,
+              );
+            }
+          } else {
+            // User has access but hasn't created a sandbox yet.
+            this.sandboxProject = true;
+            this.loadSandboxState.pass();
+            return;
+          }
+        }
+      }
+
+      // Slow path — original flow.
       const sandboxProject = (
         (yield this.sdlcServerClient.getProjects(
           undefined,
-          this.sdlcServerClient.currentUser?.userId,
+          userId,
           [SANDBOX_SDLC_TAG],
           1,
         )) as PlainObject<Project>[]
@@ -471,7 +524,7 @@ export class WorkspaceSetupStore {
       if (this.hasSandboxAccess === undefined) {
         this.hasSandboxAccess =
           (yield this.graphManagerState.graphManager.userHasPrototypeProjectAccess(
-            this.sdlcServerClient.currentUser?.userId ?? '',
+            userId ?? '',
           )) as boolean;
       }
       this.sandboxProject = true;
@@ -482,6 +535,23 @@ export class WorkspaceSetupStore {
       } else if (sandboxProject.length === 1) {
         this.sandboxProject = guaranteeNonNullable(sandboxProject[0]);
       }
+
+      // Persist the fresh result for next time. We only cache when we have
+      // a userId (cache is scoped per user); anonymous sessions skip this.
+      if (userId) {
+        LegendStudioUserDataHelper.workspaceSetup_recordSandboxInfo(
+          this.applicationStore.userDataService,
+          {
+            userId,
+            hasAccess: this.hasSandboxAccess,
+            projectId:
+              this.sandboxProject instanceof Project
+                ? this.sandboxProject.projectId
+                : undefined,
+          },
+        );
+      }
+
       this.loadSandboxState.pass();
     } catch (error) {
       this.sandboxProject = true;