[Analyze 2718] New wizards flow in wizards page (#2897)

* feat(wizards): add MRI query cache identity

* feat(wizards): add cohort cache lifecycle

* feat(wizards): add direct dashboard orchestration

* feat(wizards): embed ShinyLive dashboard

* test(cohorts): preserve wizard cache visibility

* chore(wizards): add safe dashboard diagnostics

* fix(wizards): encode cohort materialization query

* fix(wizards): fill dashboard modal height

* fix(wizards): grow form card with content

* feat(wizards): show dashboard action only

* style(wizards): align dashboard loading modal

* feat(wizards): add back navigation to wizard title

* docs(wizards): explain MRI query comparison

* refactor(wizards): retain hidden cohort action

* feat(bookmarks): return created bookmark id

* refactor(wizards): resolve cohort from bookmark id

* refactor(wizards): remove dashboard diagnostics

Author: jerome-ng

plugins/functions/bookmark-svc/src/bookmark/bookmark.service.ts

@@ -195,8 +195,8 @@ export async function _insertBookmark(
       userName
     )
     const portalAPI = new PortalAPI(token)
-    const result = await portalAPI.createBookmark({ serviceArtifact: bookmarkDto }, datasetId)
-    callback(null, result)
+    await portalAPI.createBookmark({ serviceArtifact: bookmarkDto }, datasetId)
+    callback(null, { status: 'success', bmkId: bookmarkDto.id })
   } catch (error) {
     console.error(error)
     callback(error, null)
@@ -493,7 +493,7 @@ export async function queryBookmarks(
           shareBookmark,
           token,
           datasetId,
-          cb
+          callback
         )
         break
       case 'delete':

plugins/ui/apps/vue-mri-ui-lib/src/utils/__tests__/wizardCacheVisibility.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+import { processBookmarksData } from '../BookmarkUtils'
+
+describe('processBookmarksData Wizard cache regression', () => {
+  it('keeps reserved Wizard cache artifacts visible until a hiding policy is explicitly approved', () => {
+    const wizardBookmark = bookmark({
+      bmkId: 'wizard-bookmark',
+      bookmarkname: 'wizards-1783670400000',
+      cohortDefinitionId: 42,
+    })
+    const linkedCohort = materializedCohort({
+      id: 42,
+      cohortDefinitionName: 'wizards-1783670400000',
+      syntax: JSON.stringify({ datasetId: 'dataset-1', bookmarkId: 'wizard-bookmark' }),
+    })
+
+    const result = processBookmarksData([wizardBookmark, linkedCohort], 'pa-config')
+
+    expect(result.bookmarks).toEqual([wizardBookmark])
+    expect(result.materializedCohorts).toEqual([linkedCohort])
+  })
+
+  it('keeps ordinary embedded-Wizard bookmarks and cohorts unchanged', () => {
+    const namedBookmark = bookmark({
+      bmkId: 'named-bookmark',
+      bookmarkname: 'My embedded Wizard cohort',
+      cohortDefinitionId: 7,
+    })
+    const linkedCohort = materializedCohort({ id: 7, cohortDefinitionName: 'My embedded Wizard cohort' })
+
+    const result = processBookmarksData([namedBookmark, linkedCohort], 'pa-config')
+
+    expect(result.bookmarks).toEqual([namedBookmark])
+    expect(result.materializedCohorts).toEqual([linkedCohort])
+  })
+})
+
+function bookmark(overrides: Record<string, unknown> = {}) {
+  return {
+    bmkId: 'bookmark-1',
+    bookmarkname: 'My cohort',
+    bookmark: JSON.stringify({ filter: { cards: { content: [] } } }),
+    viewname: null,
+    modified: '2026-07-10T10:00:00.000Z',
+    version: 1,
+    user_id: 'researcher',
+    shared: false,
+    paConfigId: 'pa-config',
+    ...overrides,
+  }
+}
+
+function materializedCohort(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 1,
+    patientCount: 10,
+    cohortDefinitionName: 'My cohort',
+    createdOn: '2026-07-10T10:00:00.000Z',
+    description: 'Generated cohort',
+    ...overrides,
+  }
+}

plugins/ui/apps/wizards/src/api/__tests__/wizardCohortApi.test.ts

@@ -0,0 +1,164 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import client from "../../axios/request";
+import { buildMriBookmark } from "../../utils/mriQuery";
+import { buildMriMaterializationQuery } from "../../utils/mriMaterializationQuery";
+import { compressBase64, decompress } from "../../utils/cohortUrlCodec";
+import {
+  createWizardBookmark,
+  listPatientAnalyticsCohorts,
+  materializeWizardBookmark,
+  WizardCohortApiError,
+} from "../wizardCohortApi";
+
+vi.mock("../../axios/request", () => ({
+  default: {
+    get: vi.fn(),
+    post: vi.fn(),
+  },
+}));
+
+const mockedGet = vi.mocked(client.get);
+const mockedPost = vi.mocked(client.post);
+
+describe("Wizard cohort API", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("lists Patient Analytics cohorts with dataset context", async () => {
+    const controller = new AbortController();
+    const response = [{ bmkId: "bookmark-1" }];
+    mockedGet.mockResolvedValue({ data: response });
+
+    await expect(listPatientAnalyticsCohorts("dataset-1", controller.signal)).resolves.toEqual(response);
+    expect(mockedGet).toHaveBeenCalledWith("/d2e/d2e-webapi/cohortdefinition", {
+      params: { source: "pa" },
+      headers: { datasetid: "dataset-1" },
+      signal: controller.signal,
+    });
+  });
+
+  it("rejects a malformed cohort-list response", async () => {
+    mockedGet.mockResolvedValue({ data: { unexpected: true } });
+
+    await expect(listPatientAnalyticsCohorts("dataset-1")).rejects.toMatchObject({
+      name: "WizardCohortApiError",
+      operation: "list-cohorts",
+      code: "invalid-response",
+    });
+  });
+
+  it("creates a private Wizard bookmark with existing endpoint fields", async () => {
+    mockedPost.mockResolvedValue({ data: { status: "success", bmkId: "bookmark-1" } });
+    const bookmark = buildMriBookmark([], {}, { configId: "pa-config", configVersion: "7" }, "dataset-1").bookmark;
+
+    await expect(
+      createWizardBookmark({
+        datasetId: "dataset-1",
+        bookmarkname: "wizards-1783670400000",
+        bookmark,
+        paConfigId: "pa-config",
+        cdmConfigId: "cdm-config",
+        cdmConfigVersion: "3",
+      }),
+    ).resolves.toEqual({ status: "success", bmkId: "bookmark-1" });
+
+    expect(mockedPost).toHaveBeenCalledWith(
+      "/d2e/analytics-svc/api/services/bookmark",
+      {
+        cmd: "insert",
+        bookmarkname: "wizards-1783670400000",
+        bookmark: JSON.stringify(bookmark),
+        shareBookmark: false,
+        paConfigId: "pa-config",
+        cdmConfigId: "cdm-config",
+        cdmConfigVersion: "3",
+        datasetId: "dataset-1",
+      },
+      { headers: { datasetid: "dataset-1" } },
+    );
+  });
+
+  it("rejects bookmark creation when the backend omits the bookmark id", async () => {
+    mockedPost.mockResolvedValue({ data: { status: "success" } });
+    const bookmark = buildMriBookmark([], {}, { configId: "pa-config", configVersion: "7" }, "dataset-1").bookmark;
+
+    await expect(
+      createWizardBookmark({
+        datasetId: "dataset-1",
+        bookmarkname: "wizards-1783670400000",
+        bookmark,
+        paConfigId: "pa-config",
+        cdmConfigId: "cdm-config",
+        cdmConfigVersion: "3",
+      }),
+    ).rejects.toMatchObject({ operation: "create-bookmark", code: "invalid-response" });
+  });
+
+  it("materializes a Wizard bookmark with the existing cohort payload", async () => {
+    mockedPost.mockResolvedValue({ data: "Cohort successfully materialized" });
+    const bookmark = buildMriBookmark([], {}, { configId: "pa-config", configVersion: "7" }, "dataset-1").bookmark;
+    const mriQuery = buildMriMaterializationQuery(bookmark, "dataset-1");
+
+    await materializeWizardBookmark({
+      datasetId: "dataset-1",
+      bookmarkId: "bookmark-1",
+      bookmarkName: "wizards-1783670400000",
+      description: "Generated by Wizards",
+      mriQuery,
+    });
+
+    expect(mockedPost).toHaveBeenCalledWith(
+      "/d2e/analytics-svc/api/services/cohort",
+      {
+        datasetId: "dataset-1",
+        mriquery: compressBase64(mriQuery),
+        name: "wizards-1783670400000",
+        description: "Generated by Wizards",
+        syntax: JSON.stringify({ datasetId: "dataset-1", bookmarkId: "bookmark-1" }),
+      },
+      { headers: { datasetid: "dataset-1" } },
+    );
+    const submittedPayload = mockedPost.mock.calls[0][1] as { mriquery: string };
+    expect(decompress(submittedPayload.mriquery)).toEqual(mriQuery);
+  });
+
+  it("rejects bookmark creation across datasets before making a request", async () => {
+    const bookmark = buildMriBookmark([], {}, { configId: "pa-config", configVersion: "7" }, "dataset-2").bookmark;
+
+    await expect(
+      createWizardBookmark({
+        datasetId: "dataset-1",
+        bookmarkname: "wizards-1783670400000",
+        bookmark,
+        paConfigId: "pa-config",
+        cdmConfigId: "cdm-config",
+        cdmConfigVersion: "3",
+      }),
+    ).rejects.toMatchObject({ code: "invalid-input" });
+    expect(mockedPost).not.toHaveBeenCalled();
+  });
+
+  it("wraps transport failures without exposing the backend body", async () => {
+    mockedGet.mockRejectedValue({
+      message: "sensitive backend detail",
+      response: { status: 503, data: { message: "database unavailable" } },
+    });
+
+    let caught: unknown;
+    try {
+      await listPatientAnalyticsCohorts("dataset-1");
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(WizardCohortApiError);
+    expect(caught).toMatchObject({
+      operation: "list-cohorts",
+      code: "request-failed",
+      status: 503,
+      message: "Unable to check previous Wizard analyses",
+    });
+    expect(String(caught)).not.toContain("database unavailable");
+  });
+});

plugins/ui/apps/wizards/src/api/wizardCohortApi.ts

@@ -0,0 +1,149 @@
+import type { AxiosError } from "axios";
+import client from "../axios/request";
+import type { MriMaterializationQuery } from "../utils/mriMaterializationQuery";
+import type { MriBookmark } from "../utils/mriQuery";
+import { compressBase64 } from "../utils/cohortUrlCodec";
+
+export type WizardCohortApiOperation = "list-cohorts" | "create-bookmark" | "materialize-cohort";
+export type WizardCohortApiErrorCode = "request-failed" | "invalid-input" | "invalid-response";
+
+export class WizardCohortApiError extends Error {
+  readonly operation: WizardCohortApiOperation;
+  readonly code: WizardCohortApiErrorCode;
+  readonly status?: number;
+
+  constructor(message: string, operation: WizardCohortApiOperation, code: WizardCohortApiErrorCode, status?: number) {
+    super(message);
+    this.name = "WizardCohortApiError";
+    this.operation = operation;
+    this.code = code;
+    this.status = status;
+  }
+}
+
+export type PatientAnalyticsCohortListItem = Record<string, unknown>;
+
+export interface CreateWizardBookmarkInput {
+  datasetId: string;
+  bookmarkname: string;
+  bookmark: MriBookmark;
+  paConfigId: string;
+  cdmConfigId: string;
+  cdmConfigVersion: string;
+}
+
+export interface CreateWizardBookmarkResult {
+  status: "success";
+  bmkId: string;
+}
+
+export interface MaterializeWizardBookmarkInput {
+  datasetId: string;
+  bookmarkId: string;
+  bookmarkName: string;
+  description?: string;
+  mriQuery: MriMaterializationQuery;
+}
+
+const operationMessages: Record<WizardCohortApiOperation, string> = {
+  "list-cohorts": "Unable to check previous Wizard analyses",
+  "create-bookmark": "Unable to save the Wizard analysis",
+  "materialize-cohort": "Unable to generate the Wizard cohort",
+};
+
+function getHttpStatus(error: unknown): number | undefined {
+  const response = (error as Partial<AxiosError>)?.response;
+  return typeof response?.status === "number" ? response.status : undefined;
+}
+
+function wrapApiError(error: unknown, operation: WizardCohortApiOperation): WizardCohortApiError {
+  if (error instanceof WizardCohortApiError) {
+    return error;
+  }
+  return new WizardCohortApiError(operationMessages[operation], operation, "request-failed", getHttpStatus(error));
+}
+
+function requireValue(value: string, fieldName: string, operation: WizardCohortApiOperation): string {
+  if (value.length === 0) {
+    throw new WizardCohortApiError(`${fieldName} is required`, operation, "invalid-input");
+  }
+  return value;
+}
+
+export async function listPatientAnalyticsCohorts(
+  datasetId: string,
+  signal?: AbortSignal,
+): Promise<PatientAnalyticsCohortListItem[]> {
+  const operation: WizardCohortApiOperation = "list-cohorts";
+  requireValue(datasetId, "datasetId", operation);
+  try {
+    const response = await client.get("/d2e/d2e-webapi/cohortdefinition", {
+      params: { source: "pa" },
+      headers: { datasetid: datasetId },
+      signal,
+    });
+    if (!Array.isArray(response.data)) {
+      throw new WizardCohortApiError(operationMessages[operation], operation, "invalid-response");
+    }
+    return response.data as PatientAnalyticsCohortListItem[];
+  } catch (error) {
+    throw wrapApiError(error, operation);
+  }
+}
+
+export async function createWizardBookmark(input: CreateWizardBookmarkInput): Promise<CreateWizardBookmarkResult> {
+  const operation: WizardCohortApiOperation = "create-bookmark";
+  requireValue(input.datasetId, "datasetId", operation);
+  requireValue(input.bookmarkname, "bookmarkname", operation);
+  requireValue(input.paConfigId, "paConfigId", operation);
+  requireValue(input.cdmConfigId, "cdmConfigId", operation);
+  requireValue(input.cdmConfigVersion, "cdmConfigVersion", operation);
+  if (input.bookmark.datasetId !== input.datasetId) {
+    throw new WizardCohortApiError("Bookmark dataset does not match the active dataset", operation, "invalid-input");
+  }
+  try {
+    const response = await client.post(
+      "/d2e/analytics-svc/api/services/bookmark",
+      {
+        cmd: "insert",
+        bookmarkname: input.bookmarkname,
+        bookmark: JSON.stringify(input.bookmark),
+        shareBookmark: false,
+        paConfigId: input.paConfigId,
+        cdmConfigId: input.cdmConfigId,
+        cdmConfigVersion: input.cdmConfigVersion,
+        datasetId: input.datasetId,
+      },
+      { headers: { datasetid: input.datasetId } },
+    );
+    const result = response.data as Partial<CreateWizardBookmarkResult> | null;
+    if (result?.status !== "success" || typeof result.bmkId !== "string" || result.bmkId.length === 0) {
+      throw new WizardCohortApiError(operationMessages[operation], operation, "invalid-response");
+    }
+    return { status: "success", bmkId: result.bmkId };
+  } catch (error) {
+    throw wrapApiError(error, operation);
+  }
+}
+
+export async function materializeWizardBookmark(input: MaterializeWizardBookmarkInput): Promise<void> {
+  const operation: WizardCohortApiOperation = "materialize-cohort";
+  requireValue(input.datasetId, "datasetId", operation);
+  requireValue(input.bookmarkId, "bookmarkId", operation);
+  requireValue(input.bookmarkName, "bookmarkName", operation);
+  try {
+    await client.post(
+      "/d2e/analytics-svc/api/services/cohort",
+      {
+        datasetId: input.datasetId,
+        mriquery: compressBase64(input.mriQuery),
+        name: input.bookmarkName,
+        description: input.description ?? "Generated by Wizards",
+        syntax: JSON.stringify({ datasetId: input.datasetId, bookmarkId: input.bookmarkId }),
+      },
+      { headers: { datasetid: input.datasetId } },
+    );
+  } catch (error) {
+    throw wrapApiError(error, operation);
+  }
+}