@finos/legend-application-studio 28.21.42 → 28.21.44

package/src/__lib__/LegendStudioUserDataHelper.ts

@@ -45,6 +45,11 @@ export enum LEGEND_STUDIO_USER_DATA_KEY {
   // sandbox-tag project search on every mount. Revalidated against SDLC in
   // the background; invalidated automatically on 404 or after the TTL.
   WORKSPACE_SETUP_SANDBOX_INFO = 'studio-editor.workspace-setup.sandboxInfo',
+  // Per-browser cache of the user's showcase feedback votes (thumbs up /
+  // thumbs down). Purely a UX state store so the viewer can highlight the
+  // vote the user already cast; the source of truth for aggregate analysis
+  // is the `showcase.viewer.feedback.submit` telemetry event.
+  SHOWCASE_FEEDBACK_VOTES = 'studio-editor.showcase.feedback.votes',
 }
 
 // --- Workspace setup recents -------------------------------------------------
@@ -171,6 +176,86 @@ export class CachedSandboxInfo {
   );
 }
 
+// --- Showcase feedback votes -------------------------------------------------
+
+const SHOWCASE_FEEDBACK_VOTES_VERSION = 1;
+// Cap the store so it can't grow without bound as users vote across many
+// showcases. Older votes fall off first — this is purely a UX cache so
+// losing very old entries just means the button state won't be pre-filled;
+// the telemetry event is still the source of truth.
+const MAX_SHOWCASE_FEEDBACK_VOTES = 200;
+
+export class ShowcaseFeedbackVote {
+  showcasePath!: string;
+  vote!: 'up' | 'down';
+  votedAt!: number;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(ShowcaseFeedbackVote, {
+      showcasePath: primitive(),
+      // Stored as a plain string; validated on read.
+      vote: primitive(),
+      votedAt: primitive(),
+    }),
+  );
+}
+
+export class ShowcaseFeedbackVotes {
+  version: number = SHOWCASE_FEEDBACK_VOTES_VERSION;
+  votes: ShowcaseFeedbackVote[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(ShowcaseFeedbackVotes, {
+      version: primitive(),
+      votes: list(usingModelSchema(ShowcaseFeedbackVote.serialization.schema)),
+    }),
+  );
+}
+
+const isValidShowcaseVote = (v: unknown): v is 'up' | 'down' =>
+  v === 'up' || v === 'down';
+
+const emptyShowcaseFeedbackVotes = (): ShowcaseFeedbackVotes =>
+  new ShowcaseFeedbackVotes();
+
+const readShowcaseFeedbackVotes = (
+  service: UserDataService,
+): ShowcaseFeedbackVotes => {
+  const raw = returnUndefOnError(() =>
+    service.getObjectValue(LEGEND_STUDIO_USER_DATA_KEY.SHOWCASE_FEEDBACK_VOTES),
+  );
+  if (!raw) {
+    return emptyShowcaseFeedbackVotes();
+  }
+  const parsed = returnUndefOnError(() =>
+    ShowcaseFeedbackVotes.serialization.fromJson(
+      raw as PlainObject<ShowcaseFeedbackVotes>,
+    ),
+  );
+  if (!parsed) {
+    return emptyShowcaseFeedbackVotes();
+  }
+  // Reset the store on any future schema-version bump; old entries were
+  // written under a different shape and can't be trusted.
+  if (parsed.version !== SHOWCASE_FEEDBACK_VOTES_VERSION) {
+    return emptyShowcaseFeedbackVotes();
+  }
+  parsed.votes = parsed.votes
+    .filter((v) => isValidShowcaseVote(v.vote))
+    .slice(0, MAX_SHOWCASE_FEEDBACK_VOTES);
+  return parsed;
+};
+
+const writeShowcaseFeedbackVotes = (
+  service: UserDataService,
+  store: ShowcaseFeedbackVotes,
+): void => {
+  service.persistValue(
+    LEGEND_STUDIO_USER_DATA_KEY.SHOWCASE_FEEDBACK_VOTES,
+    ShowcaseFeedbackVotes.serialization.toJson(store),
+  );
+};
+
 export class LegendStudioUserDataHelper {
   static globalTestRunner_getShowDependencyPanel(
     service: UserDataService,
@@ -378,4 +463,34 @@ export class LegendStudioUserDataHelper {
       undefined,
     );
   }
+
+  // --- Showcase feedback votes -------------------------------------------
+
+  static showcaseFeedback_getVote(
+    service: UserDataService,
+    showcasePath: string,
+  ): ShowcaseFeedbackVote | undefined {
+    return readShowcaseFeedbackVotes(service).votes.find(
+      (v) => v.showcasePath === showcasePath,
+    );
+  }
+
+  static showcaseFeedback_recordVote(
+    service: UserDataService,
+    entry: {
+      showcasePath: string;
+      vote: 'up' | 'down';
+    },
+  ): void {
+    const store = readShowcaseFeedbackVotes(service);
+    const next = new ShowcaseFeedbackVote();
+    next.showcasePath = entry.showcasePath;
+    next.vote = entry.vote;
+    next.votedAt = Date.now();
+    store.votes = [
+      next,
+      ...store.votes.filter((v) => v.showcasePath !== entry.showcasePath),
+    ].slice(0, MAX_SHOWCASE_FEEDBACK_VOTES);
+    writeShowcaseFeedbackVotes(service, store);
+  }
 }

package/src/application/LegendStudioApplicationConfig.ts

@@ -208,11 +208,20 @@ export interface LegendStudioApplicationConfigurationData
      * the SDLC server's OAuth client allow-list.
      */
     enablePopupReAuth?: boolean;
+    /**
+     * When `true`, the SDLC server is authenticated exclusively via the
+     * session cookie, never via an `Authorization: Bearer` header.
+     *
+     * See `SDLCServerClientConfig.useCookieAuthOnly`.
+     */
+    useCookieAuthOnly?: boolean;
   };
   depot: { url: string };
   engine: {
     url: string;
     queryUrl?: string;
+    useCookieAuthOnly?: boolean;
+    queryClientName?: string;
   };
   query?: { url: string };
   showcase?: { url: string };
@@ -225,11 +234,14 @@ export class LegendStudioApplicationConfig extends LegendApplicationConfig {
 
   readonly engineServerUrl: string;
   readonly engineQueryServerUrl?: string | undefined;
+  readonly engineQueryClientName?: string | undefined;
+  readonly engineUseCookieAuthOnly: boolean;
   readonly depotServerUrl: string;
   readonly sdlcServerUrl: string;
   readonly sdlcServerBaseHeaders?: RequestHeaders | undefined;
   readonly sdlcServerClient?: string | undefined;
   readonly sdlcEnablePopupReAuth: boolean;
+  readonly sdlcUseCookieAuthOnly: boolean;
   readonly queryApplicationUrl?: string | undefined;
   readonly showcaseServerUrl?: string | undefined;
   readonly pctReportUrl?: string | undefined;
@@ -256,6 +268,10 @@ export class LegendStudioApplicationConfig extends LegendApplicationConfig {
         input.configData.engine.queryUrl,
       );
     }
+    this.engineQueryClientName = input.configData.engine.queryClientName;
+    this.engineUseCookieAuthOnly = Boolean(
+      input.configData.engine.useCookieAuthOnly,
+    );
 
     // depot
     assertNonNullable(
@@ -285,6 +301,9 @@ export class LegendStudioApplicationConfig extends LegendApplicationConfig {
     this.sdlcEnablePopupReAuth = Boolean(
       input.configData.sdlc.enablePopupReAuth,
     );
+    this.sdlcUseCookieAuthOnly = Boolean(
+      input.configData.sdlc.useCookieAuthOnly,
+    );
 
     // query
     if (input.configData.query?.url) {

package/src/components/LegendStudioWebApplication.tsx

@@ -40,6 +40,8 @@ import {
 import {
   useApplicationStore,
   LegendTokenSync,
+  ExtensionPageBoundary,
+  LegendApplicationTelemetryHelper,
 } from '@finos/legend-application';
 import {
   BrowserEnvironmentProvider,
@@ -64,6 +66,13 @@ const NotFoundPage = observer(() => {
   const currentPath =
     applicationStore.navigationService.navigator.getCurrentLocation();
 
+  useEffect(() => {
+    LegendApplicationTelemetryHelper.logEvent_RouteNotFound(
+      applicationStore.telemetryService,
+      { path: currentPath },
+    );
+  }, [applicationStore, currentPath]);
+
   const documentation = applicationStore.documentationService.getDocEntry(
     LEGEND_STUDIO_DOCUMENTATION_KEY.NOT_FOUND_HELP,
   );
@@ -280,9 +289,16 @@ export const LegendStudioWebApplicationRouter = observer(() => {
                     .map(generateExtensionUrlPattern)
                     .map((path) => (
                       <Route
-                        key={entry.key}
+                        key={`${entry.key}:${path}`}
                         path={path}
-                        element={entry.renderer()}
+                        element={
+                          <ExtensionPageBoundary
+                            entryKey={entry.key}
+                            pattern={path}
+                          >
+                            {entry.renderer()}
+                          </ExtensionPageBoundary>
+                        }
                       />
                     )),
                 )}

package/src/components/ShowcaseManager.tsx

@@ -42,6 +42,11 @@ import {
   type ShowcaseTextSearchMatchResult,
   type ShowcasesExplorerTreeNodeData,
 } from '../stores/ShowcaseManagerState.js';
+import {
+  SHOWCASE_LAUNCH_ENTRY_POINT,
+  SHOWCASE_FEEDBACK_SURFACE,
+} from '../__lib__/LegendStudioTelemetryHelper.js';
+import { ShowcaseFeedback } from './showcase/ShowcaseFeedback.js';
 import { debounce, isNonNullable } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
 import type { Showcase } from '@finos/legend-server-showcase';
@@ -86,9 +91,13 @@ const ShowcasesExplorerTreeNodeContainer = observer(
       if (!node.metadata) {
         toggleExpandNode(node);
       } else {
-        flowResult(showcaseManagerState.openShowcase(node.metadata)).catch(
-          applicationStore.alertUnhandledError,
-        );
+        flowResult(
+          showcaseManagerState.openShowcase(
+            node.metadata,
+            undefined,
+            SHOWCASE_LAUNCH_ENTRY_POINT.EXPLORER,
+          ),
+        ).catch(applicationStore.alertUnhandledError);
       }
     };
 
@@ -254,7 +263,11 @@ const ShowcaseManagerCodeSearchResult = observer(
           }\n\nClick to open showcase`}
           onClick={() => {
             flowResult(
-              showcaseManagerState.openShowcase(result.showcase),
+              showcaseManagerState.openShowcase(
+                result.showcase,
+                undefined,
+                SHOWCASE_LAUNCH_ENTRY_POINT.SEARCH_SHOWCASE_MATCH,
+              ),
             ).catch(applicationStore.alertUnhandledError);
           }}
         >
@@ -275,6 +288,7 @@ const ShowcaseManagerCodeSearchResult = observer(
                   showcaseManagerState.openShowcase(
                     result.showcase,
                     entry.line,
+                    SHOWCASE_LAUNCH_ENTRY_POINT.SEARCH_CODE_MATCH,
                   ),
                 ).catch(applicationStore.alertUnhandledError);
               }}
@@ -635,6 +649,12 @@ const ShowcaseViewer = observer(
               lineToScroll={showcaseManagerState.showcaseLineToScroll}
             />
           </div>
+          <ShowcaseFeedback
+            className="showcase-manager__viewer__feedback"
+            showcasePath={showcase.path}
+            title={showcase.title}
+            surface={SHOWCASE_FEEDBACK_SURFACE.ASSISTANT_PANEL}
+          />
         </div>
       </div>
     );

package/src/components/editor/ActivityBar.tsx

@@ -81,6 +81,7 @@ import {
   ShowcaseManagerState,
   openShowcaseManager,
 } from '../../stores/ShowcaseManagerState.js';
+import { SHOWCASE_MANAGER_ENTRY_POINT } from '../../__lib__/LegendStudioTelemetryHelper.js';
 import { toggleShowcasePanel } from './ShowcaseSideBar.js';
 import { useAuth, type AuthContextProps } from 'react-oidc-context';
 
@@ -223,7 +224,10 @@ export const ActivityBarMenu: React.FC<{
                   onClick={() =>
                     openShowcasePanel
                       ? openShowcasePanel()
-                      : openShowcaseManager(applicationStore)
+                      : openShowcaseManager(
+                          applicationStore,
+                          SHOWCASE_MANAGER_ENTRY_POINT.ACTIVITY_BAR,
+                        )
                   }
                 >
                   See Showcases

package/src/components/editor/editor-group/GrammarTextEditor.tsx

@@ -132,6 +132,12 @@ import {
   GraphEditGrammarModeState,
 } from '../../../stores/editor/GraphEditGrammarModeState.js';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../__lib__/LegendStudioEvent.js';
+import {
+  LegendStudioTelemetryHelper,
+  TEXT_MODE_ACTION,
+  TEXT_MODE_ACTION_STATUS,
+  TEXT_MODE_TOGGLE_SOURCE,
+} from '../../../__lib__/LegendStudioTelemetryHelper.js';
 import { FileSystem_FileViewer } from './ArtifactGenerationViewer.js';
 import type { FileSystem_File } from '../../../stores/editor/utils/FileSystemTreeUtils.js';
 
@@ -141,7 +147,9 @@ export const GrammarTextEditorHeaderTabContextMenu = observer(
       const editorStore = useEditorStore();
       const applicationStore = useApplicationStore();
       const leaveTextMode = applicationStore.guardUnhandledError(() =>
-        flowResult(editorStore.toggleTextMode()),
+        flowResult(
+          editorStore.toggleTextMode(TEXT_MODE_TOGGLE_SOURCE.CONTEXT_MENU),
+        ),
       );
 
       return (
@@ -766,6 +774,14 @@ const goToElement = (
       LEGEND_STUDIO_APP_EVENT.TEXT_MODE_ACTION_KEYBOARD_SHORTCUT_GO_TO_DEFINITION__LAUNCH,
     ),
   );
+  LegendStudioTelemetryHelper.logEvent_TextModeAction(
+    grammarModeState.editorStore.applicationStore.telemetryService,
+    grammarModeState.editorStore.editorMode.getSourceInfo(),
+    {
+      action: TEXT_MODE_ACTION.GO_TO_DEFINITION,
+      status: TEXT_MODE_ACTION_STATUS.LAUNCH,
+    },
+  );
   const elementPath = resolveElementPathFromCurrentPosition(
     _editor,
     grammarModeState,
@@ -882,6 +898,7 @@ export const GrammarTextEditor = observer(() => {
       });
       _editor.onDidChangeModelContent(() => {
         grammarTextEditorState.setGraphGrammarText(getCodeEditorValue(_editor));
+        grammarModeState.notifyGrammarTextEdited();
         clearMarkers();
         // NOTE: we can technically can reset the current element label regex string here
         // but if we do that on first load, the cursor will not jump to the current element

package/src/components/editor/editor-group/data-editor/RelationElementSampleValuesEditor.tsx

@@ -0,0 +1,285 @@
+/**
+ * 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 { observer } from 'mobx-react-lite';
+import { useState, type CSSProperties } from 'react';
+import {
+  Dialog,
+  LongArrowRightIcon,
+  Modal,
+  ModalBody,
+  ModalFooter,
+  ModalFooterButton,
+  ModalHeader,
+  PencilEditIcon,
+  PlusIcon,
+  Tooltip,
+} from '@finos/legend-art';
+import {
+  ActionAlertActionType,
+  ActionAlertType,
+} from '@finos/legend-application';
+import type { RelationElementState } from '../../../../stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.js';
+import { RelationElementEditor } from './RelationElementsDataEditor.js';
+import { useEditorStore } from '../../EditorStoreProvider.js';
+
+export interface RelationElementSampleValuesReadOnlySource {
+  label: string;
+  message?: string | undefined;
+  onNavigate: () => void;
+}
+
+export const RelationElementSampleValuesEditor = observer(
+  (props: {
+    title: string;
+    relationElementState: RelationElementState | undefined;
+    isReadOnly: boolean;
+    isBusy?: boolean | undefined;
+    hideColumnDefinitions?: boolean | undefined;
+    deleteConfirmMessage: string;
+    onAdd: () => Promise<void> | void;
+    onDelete: () => void;
+    hasMismatch?: boolean | undefined;
+    mismatchMessage?: string | undefined;
+    readOnlySource?: RelationElementSampleValuesReadOnlySource | undefined;
+  }) => {
+    const {
+      title,
+      relationElementState,
+      isReadOnly,
+      isBusy,
+      hideColumnDefinitions,
+      deleteConfirmMessage,
+      onAdd,
+      onDelete,
+      hasMismatch,
+      mismatchMessage,
+      readOnlySource,
+    } = props;
+    const editorStore = useEditorStore();
+    const [isModalOpen, setIsModalOpen] = useState(false);
+    const isEditMode = Boolean(relationElementState) || Boolean(readOnlySource);
+
+    const closeModal = (): void => setIsModalOpen(false);
+
+    const handleClick = (): void => {
+      if (isEditMode) {
+        setIsModalOpen(true);
+        return;
+      }
+      Promise.resolve(onAdd())
+        .then(() => setIsModalOpen(true))
+        .catch(editorStore.applicationStore.alertUnhandledError);
+    };
+
+    const handleDelete = (): void => {
+      editorStore.applicationStore.alertService.setActionAlertInfo({
+        message: deleteConfirmMessage,
+        type: ActionAlertType.CAUTION,
+        actions: [
+          {
+            label: 'Confirm',
+            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+            handler: (): void => {
+              onDelete();
+              closeModal();
+            },
+          },
+          {
+            label: 'Cancel',
+            type: ActionAlertActionType.PROCEED,
+            default: true,
+          },
+        ],
+      });
+    };
+
+    const buttonStyle: CSSProperties = {
+      cursor: isReadOnly ? 'not-allowed' : 'pointer',
+    };
+    if (relationElementState && !readOnlySource) {
+      buttonStyle.border = hasMismatch
+        ? '2px solid var(--color-red-300)'
+        : '1px solid var(--color-blue-200)';
+    }
+
+    return (
+      <>
+        <button
+          className="access-point-editor__sample-values-btn"
+          onClick={handleClick}
+          disabled={isReadOnly || isBusy}
+          title={isEditMode ? 'Edit sample values' : 'Add sample values'}
+          style={buttonStyle}
+        >
+          {isEditMode ? <PencilEditIcon /> : <PlusIcon />}
+          <span>Sample Values</span>
+        </button>
+        {isModalOpen && (
+          <Dialog
+            open={isModalOpen}
+            onClose={closeModal}
+            classes={{
+              root: 'editor-modal__root-container',
+              container: 'editor-modal__container',
+              paper: 'editor-modal__content',
+            }}
+          >
+            <Modal
+              className="editor-modal"
+              darkMode={
+                !editorStore.applicationStore.layoutService
+                  .TEMPORARY__isLightColorThemeEnabled
+              }
+            >
+              <ModalHeader title={title} />
+              <ModalBody>
+                <div
+                  style={{
+                    padding: 0,
+                    height: '100%',
+                    flex: 1,
+                    overflowY: 'auto',
+                    overflowX: 'hidden',
+                  }}
+                >
+                  {readOnlySource ? (
+                    <div
+                      style={{
+                        padding: '1.5rem',
+                        display: 'flex',
+                        alignItems: 'center',
+                        justifyContent: 'center',
+                        gap: '1rem',
+                      }}
+                    >
+                      <span
+                        style={{
+                          color: 'var(--color-light-grey-200)',
+                          whiteSpace: 'nowrap',
+                          fontSize: '1.3rem',
+                          fontWeight: 600,
+                        }}
+                      >
+                        {readOnlySource.message ??
+                          'Sample Values already in Data Element'}
+                      </span>
+                      <div
+                        style={{
+                          display: 'flex',
+                          alignItems: 'center',
+                          gap: '0.5rem',
+                          padding: '0.5rem 1rem',
+                          background: 'var(--color-dark-grey-100)',
+                          border: '1px solid var(--color-dark-grey-300)',
+                          borderRadius: '0.2rem',
+                        }}
+                      >
+                        <span
+                          style={{
+                            fontSize: '1.3rem',
+                            fontWeight: 600,
+                            color: 'var(--color-light-grey-200)',
+                          }}
+                        >
+                          {readOnlySource.label}
+                        </span>
+                        <button
+                          className="btn--sm btn--dark"
+                          onClick={readOnlySource.onNavigate}
+                          tabIndex={-1}
+                          title="Navigate to data element"
+                          style={{
+                            padding: '0.3rem 0.5rem',
+                            display: 'flex',
+                            alignItems: 'center',
+                          }}
+                        >
+                          <LongArrowRightIcon />
+                        </button>
+                      </div>
+                    </div>
+                  ) : (
+                    <>
+                      <div
+                        style={{
+                          color: 'var(--color-orange-200)',
+                          fontWeight: 'bold',
+                          fontSize: '14px',
+                          padding: '0.5rem',
+                          marginBottom: '1rem',
+                          textAlign: 'center',
+                          backgroundColor: 'var(--color-orange-50)',
+                          border: '2px solid var(--color-orange-200)',
+                          borderRadius: '4px',
+                        }}
+                      >
+                        DO NOT ADD SENSITIVE DATA
+                      </div>
+                      {relationElementState && (
+                        <Tooltip
+                          title={mismatchMessage ?? ''}
+                          arrow={true}
+                          placement="top"
+                          disableHoverListener={!hasMismatch}
+                        >
+                          <div
+                            style={{
+                              border: hasMismatch
+                                ? '2px solid var(--color-red-300)'
+                                : 'none',
+                              borderRadius: '4px',
+                              padding: hasMismatch ? '0.5rem' : '0',
+                            }}
+                          >
+                            <RelationElementEditor
+                              relationElementState={relationElementState}
+                              isReadOnly={isReadOnly}
+                              {...(hideColumnDefinitions !== undefined
+                                ? { hideColumnDefinitions }
+                                : {})}
+                            />
+                          </div>
+                        </Tooltip>
+                      )}
+                    </>
+                  )}
+                </div>
+              </ModalBody>
+              <ModalFooter>
+                {!readOnlySource && (
+                  <ModalFooterButton
+                    title="Delete sample values"
+                    onClick={handleDelete}
+                    text="Delete"
+                    type="secondary"
+                    disabled={isReadOnly}
+                  />
+                )}
+                <ModalFooterButton
+                  title="Close sample values editor"
+                  onClick={closeModal}
+                  text="Close"
+                  type="secondary"
+                />
+              </ModalFooter>
+            </Modal>
+          </Dialog>
+        )}
+      </>
+    );
+  },
+);