Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

chore: onboarding guide auto-generate the select statement (#21452)

ecmadaoa2ed767c9d3c
diff --git a/frontend/src/components/SQLEditorButton.test.tsx b/frontend/src/components/SQLEditorButton.test.tsx
index c3a2e3e9e8..3083cec8b7 100644
--- a/frontend/src/components/SQLEditorButton.test.tsx
+++ b/frontend/src/components/SQLEditorButton.test.tsx
@@ -88,6 +88,25 @@ describe("SQLEditorButton", () => {
).toHaveAttribute("href", "/sql-editor/resolved");
});
+ test("forwards query parameters to the SQL Editor route", () => {
+ render(
+ <SQLEditorButton
+ database={database}
+ query={{ schema: "public", table: "users", intro: "run-query" }}
+ />
+ );
+
+ expect(mocks.resolve).toHaveBeenCalledWith({
+ name: SQL_EDITOR_DATABASE_MODULE,
+ params: {
+ project: "database-project",
+ instance: "prod",
+ database: "customers",
+ },
+ query: { schema: "public", table: "users", intro: "run-query" },
+ });
+ });
+
test("builds a project route when only a project is provided", () => {
render(<SQLEditorButton project={project} />);
diff --git a/frontend/src/components/SQLEditorButton.tsx b/frontend/src/components/SQLEditorButton.tsx
index c48a185e49..3bdbd0c157 100644
--- a/frontend/src/components/SQLEditorButton.tsx
+++ b/frontend/src/components/SQLEditorButton.tsx
@@ -25,6 +25,7 @@ export type SQLEditorButtonProps = Omit<
label?: ReactNode;
openInNewTab?: boolean;
disabled?: boolean;
+ query?: Record<string, string>;
};
export function SQLEditorButton({
@@ -33,6 +34,7 @@ export function SQLEditorButton({
label,
openInNewTab = false,
disabled = false,
+ query,
appearance,
size,
variant,
@@ -47,47 +49,48 @@ export function SQLEditorButton({
const accessibleLabel =
ariaLabel ?? (typeof label === "string" ? label : defaultLabel);
const to = useMemo(() => {
+ let target;
if (database) {
- return autoSQLEditorDatabaseRoute(database);
- }
- if (project) {
- return {
+ target = autoSQLEditorDatabaseRoute(database);
+ } else if (project) {
+ target = {
name: SQL_EDITOR_PROJECT_MODULE,
params: {
project: extractProjectResourceName(project.name),
},
};
+ } else {
+ const projectId = getRouteParam(
+ route.params.projectId ?? route.params.project
+ );
+ const instanceId = getRouteParam(
+ route.params.instanceId ?? route.params.instance
+ );
+ const databaseName = getRouteParam(
+ route.params.databaseName ?? route.params.database
+ );
+ if (projectId && instanceId && databaseName) {
+ target = {
+ name: SQL_EDITOR_DATABASE_MODULE,
+ params: {
+ project: projectId,
+ instance: instanceId,
+ database: databaseName,
+ },
+ };
+ } else if (projectId) {
+ target = {
+ name: SQL_EDITOR_PROJECT_MODULE,
+ params: {
+ project: projectId,
+ },
+ };
+ } else {
+ target = { name: SQL_EDITOR_HOME_MODULE };
+ }
}
-
- const projectId = getRouteParam(
- route.params.projectId ?? route.params.project
- );
- const instanceId = getRouteParam(
- route.params.instanceId ?? route.params.instance
- );
- const databaseName = getRouteParam(
- route.params.databaseName ?? route.params.database
- );
- if (projectId && instanceId && databaseName) {
- return {
- name: SQL_EDITOR_DATABASE_MODULE,
- params: {
- project: projectId,
- instance: instanceId,
- database: databaseName,
- },
- };
- }
- if (projectId) {
- return {
- name: SQL_EDITOR_PROJECT_MODULE,
- params: {
- project: projectId,
- },
- };
- }
- return { name: SQL_EDITOR_HOME_MODULE };
- }, [database, project, route.params]);
+ return query ? { ...target, query } : target;
+ }, [database, project, query, route.params]);
return (
<RouterLink
diff --git a/frontend/src/lib/productIntro.ts b/frontend/src/lib/productIntro.ts
index 57b5ef32fb..dac8eee85e 100644
--- a/frontend/src/lib/productIntro.ts
+++ b/frontend/src/lib/productIntro.ts
@@ -17,6 +17,7 @@ export const DOMAIN_RESTRICTION_PRODUCT_INTRO = "domain-restriction";
export const CREATE_USER_PRODUCT_INTRO = "create-user";
export const GRANT_ACCESS_PRODUCT_INTRO = "grant-access";
export const MARK_SENSITIVE_DATA_PRODUCT_INTRO = "mark-sensitive-data";
+export const RUN_QUERY_PRODUCT_INTRO = "run-query";
export type ProductIntroOptions = {
id: string;
diff --git a/frontend/src/modules/sql-editor/components/EditorAction.test.tsx b/frontend/src/modules/sql-editor/components/EditorAction.test.tsx
index 826fd5d905..d1ba13375e 100644
--- a/frontend/src/modules/sql-editor/components/EditorAction.test.tsx
+++ b/frontend/src/modules/sql-editor/components/EditorAction.test.tsx
@@ -29,6 +29,7 @@ const mocks = vi.hoisted(() => ({
canCreateSavedQueryInProject: vi.fn(() => true),
keyboardShortcutStr: vi.fn((s: string) => s),
emit: vi.fn(),
+ useProductIntro: vi.fn(),
}));
vi.mock("react-i18next", () => ({
@@ -83,6 +84,11 @@ vi.mock("@/modules/sql-editor/model/events", () => ({
sqlEditorEvents: { emit: mocks.emit },
}));
+vi.mock("@/lib/productIntro", () => ({
+ RUN_QUERY_PRODUCT_INTRO: "run-query",
+ useProductIntro: mocks.useProductIntro,
+}));
+
vi.mock("@/components/ui/button", () => ({
Button: ({
children,
@@ -90,17 +96,20 @@ vi.mock("@/components/ui/button", () => ({
disabled,
className,
"aria-label": ariaLabel,
+ "data-product-intro-target": productIntroTarget,
}: {
children: React.ReactNode;
onClick?: (e: React.MouseEvent) => void;
disabled?: boolean;
className?: string;
"aria-label"?: string;
+ "data-product-intro-target"?: string;
}) => (
<button
data-testid="button"
aria-label={ariaLabel}
className={className}
+ data-product-intro-target={productIntroTarget}
disabled={disabled}
onClick={onClick}
>
@@ -299,6 +308,34 @@ describe("EditorAction", () => {
unmount();
});
+ test.each([
+ { isDisconnected: false, statement: "SELECT 1", disabled: false },
+ { isDisconnected: true, statement: "SELECT 1", disabled: true },
+ { isDisconnected: false, statement: "", disabled: true },
+ ])(
+ "highlights Run only when connection and statement are ready",
+ ({ isDisconnected, statement, disabled }) => {
+ setup({ isDisconnected, statement });
+
+ const { container, render, unmount } = renderIntoContainer(
+ <EditorAction onExecute={vi.fn()} />
+ );
+ render();
+
+ expect(mocks.useProductIntro).toHaveBeenCalledWith({
+ id: "run-query",
+ title: "workspace-setup-guide.steps.query-data",
+ description: "workspace-setup-guide.descriptions.query-data",
+ disabled,
+ });
+ expect(
+ container.querySelector('[data-product-intro-target="run-query"]')
+ ).not.toBeNull();
+
+ unmount();
+ }
+ );
+
test("CosmosDB Run button renders an inline container selector when container is missing", () => {
setup({ engine: Engine.COSMOSDB });
const onExecute = vi.fn();
diff --git a/frontend/src/modules/sql-editor/components/EditorAction.tsx b/frontend/src/modules/sql-editor/components/EditorAction.tsx
index 8494380682..b771b2102c 100644
--- a/frontend/src/modules/sql-editor/components/EditorAction.tsx
+++ b/frontend/src/modules/sql-editor/components/EditorAction.tsx
@@ -9,6 +9,7 @@ import {
} from "@/components/ui/popover";
import { Tooltip } from "@/components/ui/tooltip";
import { useSavedQueryAndTab } from "@/hooks/useSavedQueryAndTab";
+import { RUN_QUERY_PRODUCT_INTRO, useProductIntro } from "@/lib/productIntro";
import { useConnectionOfCurrentSQLEditorTab } from "@/modules/sql-editor/hooks/useSQLEditorState";
import { sqlEditorEvents } from "@/modules/sql-editor/model/events";
import { useSQLEditorEditorState } from "@/modules/sql-editor/store/editor";
@@ -88,6 +89,13 @@ export function EditorAction({ onExecute }: Props) {
return true;
})();
+ useProductIntro({
+ id: RUN_QUERY_PRODUCT_INTRO,
+ title: t("workspace-setup-guide.steps.query-data"),
+ description: t("workspace-setup-guide.descriptions.query-data"),
+ disabled: isAdminMode || !allowQuery,
+ });
+
const canWriteSheet = (() => {
if (!tabSavedQuery) return false;
const sheet = useAppStore.getState().getSavedQueryByName(tabSavedQuery);
@@ -174,6 +182,7 @@ export function EditorAction({ onExecute }: Props) {
) : (
<RunQueryButton
disabled={!allowQuery}
+ productIntroTarget={RUN_QUERY_PRODUCT_INTRO}
settingsDisabled={!showQueryContextSettingPopover}
onClick={handleRunQuery}
/>
diff --git a/frontend/src/modules/sql-editor/components/RunQueryButton.tsx b/frontend/src/modules/sql-editor/components/RunQueryButton.tsx
index 89d9825d61..ee9a327757 100644
--- a/frontend/src/modules/sql-editor/components/RunQueryButton.tsx
+++ b/frontend/src/modules/sql-editor/components/RunQueryButton.tsx
@@ -8,6 +8,7 @@ import { QueryContextSettingPopover } from "./QueryContextSettingPopover";
type Props = {
readonly disabled?: boolean;
+ readonly productIntroTarget?: string;
readonly settingsDisabled?: boolean;
readonly size?: "sm" | "md";
readonly type?: ComponentProps<typeof Button>["type"];
@@ -16,6 +17,7 @@ type Props = {
export function RunQueryButton({
disabled = false,
+ productIntroTarget,
settingsDisabled = disabled,
size = "sm",
type = "button",
@@ -35,6 +37,7 @@ export function RunQueryButton({
size === "sm" && "h-7"
)}
disabled={disabled}
+ data-product-intro-target={productIntroTarget}
onClick={onClick}
>
<Play className="size-4 fill-current" />
diff --git a/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.test.tsx b/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.test.tsx
index 983842f3fa..96c1ed012f 100644
--- a/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.test.tsx
+++ b/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.test.tsx
@@ -1,9 +1,15 @@
+import { create } from "@bufbuild/protobuf";
import { act } from "react";
import { createRoot } from "react-dom/client";
import { beforeEach, describe, expect, test, vi } from "vitest";
import type { ReactRoute } from "@/app/router";
import { sqlEditorEvents } from "@/modules/sql-editor/model/events";
import type { SQLEditorTab } from "@/types";
+import { Engine } from "@/types/proto-es/v1/common_pb";
+import {
+ DatabaseMetadataSchema,
+ DatabaseSchema$,
+} from "@/types/proto-es/v1/database_service_pb";
import { SQLEditorRouteShell } from "./SQLEditorRouteShell";
(
@@ -55,6 +61,7 @@ const mocks = vi.hoisted(() => {
name,
project: "projects/proj1",
})),
+ getOrFetchDatabaseMetadata: vi.fn(),
fetchInstance: vi.fn<
(name: string) => Promise<{ name: string } | undefined>
>(async (name: string) => ({ name })),
@@ -145,6 +152,7 @@ vi.mock("@/stores/app", () => ({
useAppStore: {
getState: () => ({
getOrFetchDatabaseByName: mocks.getOrFetchDatabaseByName,
+ getOrFetchDatabaseMetadata: mocks.getOrFetchDatabaseMetadata,
fetchInstance: mocks.fetchInstance,
getSavedQueryByName: mocks.getSavedQueryByName,
getOrFetchSavedQueryByName: mocks.getOrFetchSavedQueryByName,
@@ -207,6 +215,10 @@ const renderShell = () => {
});
return {
container,
+ rerender: () =>
+ act(() => {
+ root.render(<SQLEditorRouteShell />);
+ }),
unmount: () =>
act(() => {
root.unmount();
@@ -237,10 +249,26 @@ beforeEach(() => {
return tab;
}
);
- mocks.getOrFetchDatabaseByName.mockImplementation(async (name: string) => ({
- name,
- project: "projects/proj1",
- }));
+ mocks.getOrFetchDatabaseByName.mockImplementation(async (name: string) =>
+ create(DatabaseSchema$, {
+ name,
+ project: "projects/proj1",
+ instanceResource: {
+ name: "instances/inst1",
+ engine: Engine.POSTGRES,
+ },
+ })
+ );
+ mocks.getOrFetchDatabaseMetadata.mockResolvedValue(
+ create(DatabaseMetadataSchema, {
+ schemas: [
+ {
+ name: "public",
+ tables: [{ name: "users" }],
+ },
+ ],
+ })
+ );
mocks.fetchInstance.mockImplementation(async (name: string) => ({ name }));
mocks.getSavedQueryByName.mockImplementation((name: string) => ({
name,
@@ -458,6 +486,60 @@ describe("SQLEditorRouteShell", () => {
unmount();
});
+ test("opens a query tab instead of reusing a restored data explorer tab for a guided query", async () => {
+ mocks.tabsState.initProject.mockImplementationOnce(async () => {
+ const tab = {
+ id: "explorer",
+ savedQuery: "",
+ mode: "DATA_EXPLORER",
+ connection: {
+ instance: "instances/inst1",
+ database: "instances/inst1/databases/db1",
+ schema: "public",
+ table: "users",
+ },
+ dataExplorer: {
+ filter: "WHERE active = true",
+ initialized: false,
+ },
+ } as SQLEditorTab;
+ mocks.tabsState.tabsById.set(tab.id, tab);
+ mocks.tabsState.currentTabId = tab.id;
+ });
+ mocks.renderRoute = {
+ ...mocks.renderRoute,
+ query: {
+ schema: "public",
+ table: "users",
+ intro: "run-query",
+ },
+ };
+ mocks.currentRoute = mocks.renderRoute;
+
+ const { unmount } = renderShell();
+
+ await act(async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
+ connection: {
+ instance: "instances/inst1",
+ database: "instances/inst1/databases/db1",
+ schema: "public",
+ table: "users",
+ },
+ mode: "SAVED_QUERY",
+ statement: 'SELECT * FROM "public"."users" LIMIT 50;',
+ });
+ expect(mocks.tabsState.currentTabId).toBe("tab-1");
+
+ unmount();
+ });
+
test("seeds database route tabs with schema and table from the URL", async () => {
const { unmount } = renderShell();
@@ -492,6 +574,142 @@ describe("SQLEditorRouteShell", () => {
unmount();
});
+ test("generates a SELECT statement for a guided query target", async () => {
+ mocks.renderRoute = {
+ ...mocks.renderRoute,
+ query: {
+ schema: "public",
+ table: "users",
+ intro: "run-query",
+ },
+ };
+ mocks.currentRoute = mocks.renderRoute;
+
+ const { unmount } = renderShell();
+
+ await act(async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(mocks.getOrFetchDatabaseMetadata).toHaveBeenCalledWith({
+ database: "instances/inst1/databases/db1",
+ silent: true,
+ });
+ expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
+ connection: {
+ instance: "instances/inst1",
+ database: "instances/inst1/databases/db1",
+ schema: "public",
+ table: "users",
+ },
+ mode: "SAVED_QUERY",
+ statement: 'SELECT * FROM "public"."users" LIMIT 50;',
+ });
+
+ unmount();
+ });
+
+ test("generates a SELECT statement when a mounted editor receives a guided query route", async () => {
+ const { rerender, unmount } = renderShell();
+
+ await act(async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+ mocks.tabsState.addTab.mockClear();
+
+ mocks.renderRoute = {
+ ...mocks.renderRoute,
+ query: {
+ schema: "public",
+ table: "users",
+ intro: "run-query",
+ },
+ };
+ mocks.currentRoute = mocks.renderRoute;
+ rerender();
+
+ await act(async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
+ connection: {
+ instance: "instances/inst1",
+ database: "instances/inst1/databases/db1",
+ schema: "public",
+ table: "users",
+ },
+ mode: "SAVED_QUERY",
+ statement: 'SELECT * FROM "public"."users" LIMIT 50;',
+ });
+
+ unmount();
+ });
+
+ test("does not generate a statement outside the guided query intro", async () => {
+ const { unmount } = renderShell();
+
+ await act(async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(mocks.getOrFetchDatabaseMetadata).not.toHaveBeenCalled();
+ expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
+ connection: {
+ instance: "instances/inst1",
+ database: "instances/inst1/databases/db1",
+ schema: "public",
+ table: "users",
+ },
+ mode: "SAVED_QUERY",
+ });
+
+ unmount();
+ });
+
+ test("does not generate a guided statement for an unknown table", async () => {
+ mocks.renderRoute = {
+ ...mocks.renderRoute,
+ query: {
+ schema: "public",
+ table: "missing",
+ intro: "run-query",
+ },
+ };
+ mocks.currentRoute = mocks.renderRoute;
+
+ const { unmount } = renderShell();
+
+ await act(async () => {
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ await Promise.resolve();
+ });
+
+ expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
+ connection: {
+ instance: "instances/inst1",
+ database: "instances/inst1/databases/db1",
+ schema: "public",
+ table: "missing",
+ },
+ mode: "SAVED_QUERY",
+ });
+
+ unmount();
+ });
+
test("uses the render route when the imperative router snapshot is still on the parent route", async () => {
mocks.currentRoute = {
...mocks.currentRoute,
diff --git a/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.tsx b/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.tsx
index 3996d91149..2a2c6c5ba2 100644
--- a/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.tsx
+++ b/frontend/src/modules/sql-editor/components/SQLEditorRouteShell.tsx
@@ -17,6 +17,10 @@ import {
usePermissionDataReady,
} from "@/components/ComponentPermissionGuard";
import { useAppProject } from "@/hooks/useAppProject";
+import {
+ PRODUCT_INTRO_QUERY_KEY,
+ RUN_QUERY_PRODUCT_INTRO,
+} from "@/lib/productIntro";
import { extractSavedQueryConnection } from "@/lib/sqlEditorConnection";
import { useClampResultRowsLimitToPolicy } from "@/modules/sql-editor/hooks/useSQLEditorState";
import { cleanupLegacyPouchDatabases } from "@/modules/sql-editor/legacy/migration";
@@ -46,6 +50,8 @@ import {
extractInstanceResourceName,
extractProjectResourceName,
extractSavedQueryID,
+ generateSimpleSelectAllStatement,
+ getDatabaseEngine,
getSheetStatement,
isSavedQueryReadableV1,
storageKeySqlEditorSidebarTab,
@@ -86,6 +92,8 @@ const ASIDE_PANEL_TABS: readonly AsidePanelTab[] = [
"ACCESS",
];
+const GUIDED_QUERY_ROW_LIMIT = 50;
+
/**
* Owns the SQL Editor route bootstrap chain:
* - on mount, resolves the active project from URL params/query or the
@@ -104,6 +112,10 @@ export function SQLEditorRouteShell() {
const { t } = useTranslation();
const navigate = useNavigate();
const route = useCurrentRoute();
+ const guidedQueryRequested =
+ route.name === SQL_EDITOR_DATABASE_MODULE &&
+ route.query[PRODUCT_INTRO_QUERY_KEY] === RUN_QUERY_PRODUCT_INTRO;
+ const previousGuidedQueryRequestedRef = useRef(guidedQueryRequested);
const setAsidePanelTab = useSQLEditorStore((s) => s.setAsidePanelTab);
const maybeSwitchProject = useSQLEditorStore((s) => s.maybeSwitchProject);
@@ -295,9 +307,38 @@ export function SQLEditorRouteShell() {
connection.table = table;
connection.schema ??= "";
}
+ const isGuidedQuery =
+ route.query[PRODUCT_INTRO_QUERY_KEY] === RUN_QUERY_PRODUCT_INTRO;
+ let statement: string | undefined;
+ if (isGuidedQuery && typeof table === "string" && table) {
+ const metadata = await useAppStore
+ .getState()
+ .getOrFetchDatabaseMetadata({
+ database: database.name,
+ silent: true,
+ })
+ .catch(() => undefined);
+ const schemaName = typeof schema === "string" ? schema : "";
+ const targetExists = metadata?.schemas.some(
+ (schemaMetadata) =>
+ schemaMetadata.name === schemaName &&
+ schemaMetadata.tables.some(
+ (tableMetadata) => tableMetadata.name === table
+ )
+ );
+ if (targetExists) {
+ statement = generateSimpleSelectAllStatement(
+ getDatabaseEngine(database),
+ schemaName,
+ table,
+ GUIDED_QUERY_ROW_LIMIT
+ );
+ }
+ }
const tabsState = getSQLEditorTabsState();
const currentTab = tabsState.tabsById.get(tabsState.currentTabId);
if (
+ !isGuidedQuery &&
currentTab?.mode === "DATA_EXPLORER" &&
currentTab.connection.instance === connection.instance &&
currentTab.connection.database === connection.database &&
@@ -309,6 +350,7 @@ export function SQLEditorRouteShell() {
tabsState.addTab({
connection,
mode: DEFAULT_SQL_EDITOR_TAB_MODE,
+ ...(statement ? { statement } : {}),
});
return true;
};
@@ -401,6 +443,14 @@ export function SQLEditorRouteShell() {
if (await prepareConnectionParams()) return;
};
+ useEffect(() => {
+ if (!bootstrapDone) return;
+ const previouslyRequested = previousGuidedQueryRequestedRef.current;
+ previousGuidedQueryRequestedRef.current = guidedQueryRequested;
+ if (!guidedQueryRequested || previouslyRequested) return;
+ void prepareConnectionParams();
+ }, [bootstrapDone, guidedQueryRequested]);
+
// ---- URL ⇄ connection sync (reactive) --------------------------------
// Subscribe to each Zustand field; the effect below fires whenever any
diff --git a/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.test.tsx b/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.test.tsx
index 44aa1ceb88..4d57eb7050 100644
--- a/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.test.tsx
+++ b/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.test.tsx
@@ -95,11 +95,13 @@ vi.mock("@/components/HowBytebaseWorksSheet", () => ({
vi.mock("@/components/SQLEditorButton", () => ({
SQLEditorButton: ({
label,
+ query,
size,
className,
"data-testid": testId,
}: {
label?: ReactNode;
+ query?: Record<string, string>;
size?: string;
className?: string;
"data-testid"?: string;
@@ -107,6 +109,7 @@ vi.mock("@/components/SQLEditorButton", () => ({
<button
className={className}
data-testid={testId ?? "sql-editor-action"}
+ data-query={query ? JSON.stringify(query) : undefined}
data-size={size}
>
{label}
@@ -216,6 +219,7 @@ describe("WorkspaceSetupGuide", () => {
hasExploredDatabase: true,
databaseProjectName: "projects/app",
databaseName: "instances/sample/databases/employee",
+ queryTarget: { schema: "public", table: "employee" },
});
render(<WorkspaceSetupGuide />);
@@ -235,9 +239,43 @@ describe("WorkspaceSetupGuide", () => {
"data-size",
"sm"
);
+ expect(screen.getByTestId("active-action")).toHaveAttribute(
+ "data-query",
+ JSON.stringify({
+ schema: "public",
+ table: "employee",
+ intro: "run-query",
+ panel: "schema",
+ })
+ );
expect(screen.getByTestId("open-product-model")).toBeVisible();
});
+ test("hides the SQL Editor action while the Query step is on its route", () => {
+ mocks.scenarioId = "query-data";
+ mocks.guideContext = guideContext({
+ hasProject: true,
+ hasInstance: true,
+ hasExploredDatabase: true,
+ databaseProjectName: "projects/app",
+ databaseName: "instances/sample/databases/employee",
+ queryTarget: { schema: "public", table: "employee" },
+ route: {
+ name: "sql-editor.database",
+ params: {
+ project: "app",
+ instance: "sample",
+ database: "employee",
+ },
+ },
+ });
+
+ render(<WorkspaceSetupGuide />);
+
+ expect(screen.getByTestId("setup-step-query-data")).toBeVisible();
+ expect(screen.queryByTestId("active-action")).not.toBeInTheDocument();
+ });
+
test("shows the full Query Data chain when setup has no resources", () => {
mocks.scenarioId = "query-data";
diff --git a/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.tsx b/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.tsx
index 5ee87d6386..a09ec3bb6a 100644
--- a/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.tsx
+++ b/frontend/src/modules/workspace-setup-guide/WorkspaceSetupGuide.tsx
@@ -95,6 +95,8 @@ export function WorkspaceSetupGuide() {
[context, journey, selectedStepId]
);
const primaryAction = guide.actionStep?.actions.primary;
+ const isActionStepRouteActive =
+ guide.actionStep?.definition.matchesRoute(context.route) ?? false;
const guideAnalyticsProperties = useMemo(
() =>
getGuideAnalyticsProperties({
@@ -436,24 +438,27 @@ export function WorkspaceSetupGuide() {
</div>
<div className="ml-auto flex shrink-0 items-center gap-x-2">
- {!guide.complete && primaryAction?.type === "open-sql-editor" && (
- <span
- onClickCapture={() => {
- if (guide.actionStep) {
- captureStepAction(guide.actionStep, primaryAction);
- }
- }}
- >
- <SQLEditorButton
- data-testid="active-action"
- database={primaryAction.database}
- openInNewTab
- size="sm"
- className="2xl:h-9 2xl:gap-1.5 2xl:px-3 2xl:text-sm 2xl:leading-5"
- label={t("workspace-setup-guide.actions.query")}
- />
- </span>
- )}
+ {!guide.complete &&
+ !isActionStepRouteActive &&
+ primaryAction?.type === "open-sql-editor" && (
+ <span
+ onClickCapture={() => {
+ if (guide.actionStep) {
+ captureStepAction(guide.actionStep, primaryAction);
+ }
+ }}
+ >
+ <SQLEditorButton
+ data-testid="active-action"
+ database={primaryAction.database}
+ query={primaryAction.query}
+ openInNewTab
+ size="sm"
+ className="2xl:h-9 2xl:gap-1.5 2xl:px-3 2xl:text-sm 2xl:leading-5"
+ label={t("workspace-setup-guide.actions.query")}
+ />
+ </span>
+ )}
<Button
type="button"
data-testid="dismiss-guide"
diff --git a/frontend/src/modules/workspace-setup-guide/queryTarget.test.ts b/frontend/src/modules/workspace-setup-guide/queryTarget.test.ts
new file mode 100644
index 0000000000..18321debab
--- /dev/null
+++ b/frontend/src/modules/workspace-setup-guide/queryTarget.test.ts
@@ -0,0 +1,120 @@
+// @vitest-environment node
+import { create } from "@bufbuild/protobuf";
+import { describe, expect, test } from "vitest";
+import {
+ DatabaseCatalogSchema,
+ ObjectSchemaSchema,
+ TableCatalog_ColumnsSchema,
+ TableCatalogSchema,
+} from "@/types/proto-es/v1/database_catalog_service_pb";
+import {
+ DatabaseMetadataSchema,
+ SchemaMetadataSchema,
+ TableMetadataSchema,
+} from "@/types/proto-es/v1/database_service_pb";
+import { findGuideQueryTarget } from "./queryTarget";
+
+const metadata = create(DatabaseMetadataSchema, {
+ schemas: [
+ create(SchemaMetadataSchema, {
+ name: "public",
+ tables: [
+ create(TableMetadataSchema, { name: "users" }),
+ create(TableMetadataSchema, { name: "events" }),
+ ],
+ }),
+ ],
+});
+
+describe("findGuideQueryTarget", () => {
+ test("selects the first table for the query-data guide", () => {
+ expect(findGuideQueryTarget(metadata)).toEqual({
+ schema: "public",
+ table: "users",
+ });
+ });
+
+ test("selects the table containing a marked relational column", () => {
+ const catalog = create(DatabaseCatalogSchema, {
+ schemas: [
+ {
+ name: "public",
+ tables: [
+ create(TableCatalogSchema, {
+ name: "events",
+ kind: {
+ case: "columns",
+ value: create(TableCatalog_ColumnsSchema, {
+ columns: [{ name: "payload", semanticType: "bb.default" }],
+ }),
+ },
+ }),
+ ],
+ },
+ ],
+ });
+
+ expect(findGuideQueryTarget(metadata, catalog)).toEqual({
+ schema: "public",
+ table: "events",
+ });
+ });
+
+ test("selects the table containing a nested marked document field", () => {
+ const catalog = create(DatabaseCatalogSchema, {
+ schemas: [
+ {
+ name: "public",
+ tables: [
+ create(TableCatalogSchema, {
+ name: "users",
+ kind: {
+ case: "objectSchema",
+ value: create(ObjectSchemaSchema, {
+ kind: {
+ case: "structKind",
+ value: {
+ properties: {
+ profile: create(ObjectSchemaSchema, {
+ semanticType: "bb.default",
+ }),
+ },
+ },
+ },
+ }),
+ },
+ }),
+ ],
+ },
+ ],
+ });
+
+ expect(findGuideQueryTarget(metadata, catalog)).toEqual({
+ schema: "public",
+ table: "users",
+ });
+ });
+
+ test("ignores marked catalog tables missing from current metadata", () => {
+ const catalog = create(DatabaseCatalogSchema, {
+ schemas: [
+ {
+ name: "public",
+ tables: [
+ create(TableCatalogSchema, {
+ name: "removed",
+ kind: {
+ case: "columns",
+ value: create(TableCatalog_ColumnsSchema, {
+ columns: [{ name: "secret", semanticType: "bb.default" }],
+ }),
+ },
+ }),
+ ],
+ },
+ ],
+ });
+
+ expect(findGuideQueryTarget(metadata, catalog)).toBeUndefined();
+ });
+});
diff --git a/frontend/src/modules/workspace-setup-guide/queryTarget.ts b/frontend/src/modules/workspace-setup-guide/queryTarget.ts
new file mode 100644
index 0000000000..ba768c9e1b
--- /dev/null
+++ b/frontend/src/modules/workspace-setup-guide/queryTarget.ts
@@ -0,0 +1,53 @@
+import type {
+ DatabaseCatalog,
+ ObjectSchema,
+ TableCatalog,
+} from "@/types/proto-es/v1/database_catalog_service_pb";
+import type { DatabaseMetadata } from "@/types/proto-es/v1/database_service_pb";
+import type { GuideQueryTarget } from "./types";
+
+const objectSchemaHasSemanticType = (
+ schema: ObjectSchema | undefined
+): boolean => {
+ if (!schema) return false;
+ if (schema.semanticType) return true;
+ if (schema.kind.case === "structKind") {
+ return Object.values(schema.kind.value.properties).some(
+ objectSchemaHasSemanticType
+ );
+ }
+ if (schema.kind.case === "arrayKind") {
+ return objectSchemaHasSemanticType(schema.kind.value.kind);
+ }
+ return false;
+};
+
+export const tableHasMarkedSensitiveData = (
+ table: TableCatalog | undefined
+): boolean => {
+ if (table?.kind.case === "columns") {
+ return table.kind.value.columns.some((column) => !!column.semanticType);
+ }
+ if (table?.kind.case === "objectSchema") {
+ return objectSchemaHasSemanticType(table.kind.value);
+ }
+ return false;
+};
+
+export const findGuideQueryTarget = (
+ metadata: Pick<DatabaseMetadata, "schemas"> | undefined,
+ sensitiveCatalog?: Pick<DatabaseCatalog, "schemas">
+): GuideQueryTarget | undefined => {
+ for (const schema of metadata?.schemas ?? []) {
+ for (const table of schema.tables) {
+ if (sensitiveCatalog) {
+ const catalogTable = sensitiveCatalog.schemas
+ .find(({ name }) => name === schema.name)
+ ?.tables.find(({ name }) => name === table.name);
+ if (!tableHasMarkedSensitiveData(catalogTable)) continue;
+ }
+ return { schema: schema.name, table: table.name };
+ }
+ }
+ return undefined;
+};
diff --git a/frontend/src/modules/workspace-setup-guide/steps.test.ts b/frontend/src/modules/workspace-setup-guide/steps.test.ts
index 7b534c011a..6789841a38 100644
--- a/frontend/src/modules/workspace-setup-guide/steps.test.ts
+++ b/frontend/src/modules/workspace-setup-guide/steps.test.ts
@@ -40,6 +40,7 @@ const createContext = (
instanceName: "",
databaseProjectName: "",
databaseName: "",
+ queryTarget: undefined,
route: { name: "workspace.home", params: {} },
...overrides,
});
@@ -181,6 +182,7 @@ describe("GUIDE_STEP_DEFINITIONS", () => {
hasRunStatement,
databaseName: "instances/sample/databases/employee",
databaseProjectName: "projects/app",
+ queryTarget: { schema: "public", table: "employee" },
})
)
).toEqual({
@@ -193,6 +195,12 @@ describe("GUIDE_STEP_DEFINITIONS", () => {
instance: "sample",
database: "employee",
},
+ query: {
+ schema: "public",
+ table: "employee",
+ intro: "run-query",
+ panel: "schema",
+ },
},
},
primary: {
@@ -201,11 +209,47 @@ describe("GUIDE_STEP_DEFINITIONS", () => {
name: "instances/sample/databases/employee",
project: "projects/app",
},
+ query: {
+ schema: "public",
+ table: "employee",
+ intro: "run-query",
+ panel: "schema",
+ },
},
});
}
);
+ test("opens the database without the run intro when no table is known", () => {
+ expect(
+ GUIDE_STEP_BY_ID["query-data"].resolveActions(
+ createContext({
+ databaseName: "instances/sample/databases/empty",
+ databaseProjectName: "projects/app",
+ })
+ )
+ ).toEqual({
+ select: {
+ type: "navigate",
+ target: {
+ name: "sql-editor.database",
+ params: {
+ project: "app",
+ instance: "sample",
+ database: "empty",
+ },
+ },
+ },
+ primary: {
+ type: "open-sql-editor",
+ database: {
+ name: "instances/sample/databases/empty",
+ project: "projects/app",
+ },
+ },
+ });
+ });
+
test.each([false, true])(
"always opens the discovered database catalog when sensitive data completion is %s",
(hasMarkedSensitiveData) => {
diff --git a/frontend/src/modules/workspace-setup-guide/steps.ts b/frontend/src/modules/workspace-setup-guide/steps.ts
index 7638e0e5af..11e684ebb9 100644
--- a/frontend/src/modules/workspace-setup-guide/steps.ts
+++ b/frontend/src/modules/workspace-setup-guide/steps.ts
@@ -16,6 +16,7 @@ import {
MARK_SENSITIVE_DATA_PRODUCT_INTRO,
PRODUCT_INTRO_QUERY_KEY,
PROJECT_INSTANCE_SYNCED_PRODUCT_INTRO,
+ RUN_QUERY_PRODUCT_INTRO,
} from "@/lib/productIntro";
import { autoSQLEditorDatabaseRoute } from "@/utils/auto-route";
import { extractDatabaseResourceName } from "@/utils/v1/database";
@@ -108,22 +109,34 @@ export const GUIDE_STEP_DEFINITIONS: readonly GuideStepDefinition[] = [
isComplete: (context) => context.hasRunStatement,
matchesRoute: (route) =>
isRouteInside(route.name, SQL_EDITOR_DATABASE_MODULE),
- resolveActions: (context) => ({
- select: {
- type: "navigate",
- target: autoSQLEditorDatabaseRoute({
- name: context.databaseName,
- project: context.databaseProjectName,
- }),
- },
- primary: {
- type: "open-sql-editor",
- database: {
- name: context.databaseName,
- project: context.databaseProjectName,
+ resolveActions: (context) => {
+ const query = context.queryTarget
+ ? {
+ schema: context.queryTarget.schema,
+ table: context.queryTarget.table,
+ [PRODUCT_INTRO_QUERY_KEY]: RUN_QUERY_PRODUCT_INTRO,
+ panel: "schema",
+ }
+ : undefined;
+ const target = autoSQLEditorDatabaseRoute({
+ name: context.databaseName,
+ project: context.databaseProjectName,
+ });
+ return {
+ select: {
+ type: "navigate",
+ target: query ? { ...target, query } : target,
},
- },
- }),
+ primary: {
+ type: "open-sql-editor",
+ database: {
+ name: context.databaseName,
+ project: context.databaseProjectName,
+ },
+ ...(query ? { query } : {}),
+ },
+ };
+ },
},
{
id: "create-database-change",
diff --git a/frontend/src/modules/workspace-setup-guide/types.ts b/frontend/src/modules/workspace-setup-guide/types.ts
index 90b1eb4030..264a608100 100644
--- a/frontend/src/modules/workspace-setup-guide/types.ts
+++ b/frontend/src/modules/workspace-setup-guide/types.ts
@@ -16,6 +16,11 @@ export type GuideScenarioId =
export type GuideWorkspaceUsage = "team" | "solo";
+export type GuideQueryTarget = {
+ schema: string;
+ table: string;
+};
+
export type GuideJourneyId = "workspace-setup" | GuideScenarioId;
export type GuideRoute = Pick<ReactRoute, "name" | "params"> &
@@ -35,6 +40,7 @@ export type GuideContext = {
instanceName: string;
databaseProjectName: string;
databaseName: string;
+ queryTarget?: GuideQueryTarget;
route: GuideRoute;
};
@@ -45,7 +51,11 @@ export type GuideDatabase = {
export type GuideAction =
| { type: "navigate"; target: RouteTarget }
- | { type: "open-sql-editor"; database: GuideDatabase }
+ | {
+ type: "open-sql-editor";
+ database: GuideDatabase;
+ query?: Record<string, string>;
+ }
| {
type: "create-change";
project: string;
diff --git a/frontend/src/modules/workspace-setup-guide/useGuideContext.test.tsx b/frontend/src/modules/workspace-setup-guide/useGuideContext.test.tsx
index 0974589dcb..f7f477bbef 100644
--- a/frontend/src/modules/workspace-setup-guide/useGuideContext.test.tsx
+++ b/frontend/src/modules/workspace-setup-guide/useGuideContext.test.tsx
@@ -9,6 +9,11 @@ import {
import { planEvents } from "@/lib/plan/events";
import { sqlEditorEvents } from "@/modules/sql-editor/model/events";
import { DatabaseCatalogSchema } from "@/types/proto-es/v1/database_catalog_service_pb";
+import {
+ DatabaseMetadataSchema,
+ SchemaMetadataSchema,
+ TableMetadataSchema,
+} from "@/types/proto-es/v1/database_service_pb";
import { Engine } from "@/types/proto-es/v1/common_pb";
import { getGuideJourney } from "./scenarios";
import { resolveGuide } from "./resolve";
@@ -25,11 +30,13 @@ const mocks = vi.hoisted(() => ({
instancesByName: {} as Record<string, unknown>,
databasesByName: {} as Record<string, unknown>,
catalogsByName: {} as Record<string, unknown>,
+ metadataByDatabase: {} as Record<string, unknown>,
usersByName: {} as Record<string, unknown>,
fetchProjectList: vi.fn(),
fetchInstanceList: vi.fn(),
fetchDatabases: vi.fn(),
getOrFetchDatabaseCatalog: vi.fn(),
+ getOrFetchDatabaseMetadata: vi.fn(),
listUsers: vi.fn(),
introState: {} as Record<string, boolean>,
saveIntroStateByKey: vi.fn(),
@@ -68,6 +75,8 @@ vi.mock("@/stores/app", () => {
currentUserName: mocks.currentUserName,
workspacePolicy: mocks.workspacePolicy,
isSaaSMode: () => mocks.isSaaS,
+ getCachedDatabaseMetadata: (database: string) =>
+ mocks.metadataByDatabase[database],
});
const useAppStore = Object.assign(
(selector: (value: ReturnType<typeof state>) => unknown) =>
@@ -79,6 +88,7 @@ vi.mock("@/stores/app", () => {
fetchInstanceList: mocks.fetchInstanceList,
fetchDatabases: mocks.fetchDatabases,
getOrFetchDatabaseCatalog: mocks.getOrFetchDatabaseCatalog,
+ getOrFetchDatabaseMetadata: mocks.getOrFetchDatabaseMetadata,
listUsers: mocks.listUsers,
getIntroStateByKey: (key: string) => mocks.introState[key] ?? false,
saveIntroStateByKey: mocks.saveIntroStateByKey,
@@ -154,6 +164,7 @@ describe("useGuideContext", () => {
mocks.instancesByName = {};
mocks.databasesByName = {};
mocks.catalogsByName = {};
+ mocks.metadataByDatabase = {};
mocks.usersByName = {};
mocks.fetchProjectList.mockResolvedValue({ projects: [], nextPageToken: "" });
mocks.fetchInstanceList.mockResolvedValue({
@@ -162,6 +173,9 @@ describe("useGuideContext", () => {
});
mocks.fetchDatabases.mockResolvedValue({ databases: [], nextPageToken: "" });
mocks.getOrFetchDatabaseCatalog.mockResolvedValue({ schemas: [] });
+ mocks.getOrFetchDatabaseMetadata.mockImplementation(async ({ database }) => {
+ return mocks.metadataByDatabase[database];
+ });
mocks.listUsers.mockResolvedValue({ users: [], nextPageToken: "" });
mocks.currentUserName = "users/[email protected]";
mocks.isSaaS = false;
@@ -279,6 +293,85 @@ describe("useGuideContext", () => {
expect(result.current.context.hasMarkedSensitiveData).toBe(true);
});
+ test("resolves the first table for the query-data action", async () => {
+ mockDiscoveredDatabase();
+ const database = "instances/sample/databases/employee";
+ mocks.metadataByDatabase[database] = create(DatabaseMetadataSchema, {
+ schemas: [
+ create(SchemaMetadataSchema, {
+ name: "public",
+ tables: [create(TableMetadataSchema, { name: "employee" })],
+ }),
+ ],
+ });
+
+ const { result } = renderGuideContext({
+ enabled: true,
+ dismissed: false,
+ route: home,
+ scenarioId: "query-data",
+ });
+
+ await waitFor(() =>
+ expect(result.current.context.queryTarget).toEqual({
+ schema: "public",
+ table: "employee",
+ })
+ );
+ expect(mocks.getOrFetchDatabaseMetadata).toHaveBeenCalledWith({
+ database,
+ silent: true,
+ });
+ });
+
+ test("resolves the marked table for the masking verification action", async () => {
+ mockDiscoveredDatabase();
+ const database = "instances/sample/databases/employee";
+ mocks.metadataByDatabase[database] = create(DatabaseMetadataSchema, {
+ schemas: [
+ create(SchemaMetadataSchema, {
+ name: "public",
+ tables: [
+ create(TableMetadataSchema, { name: "employee" }),
+ create(TableMetadataSchema, { name: "salary" }),
+ ],
+ }),
+ ],
+ });
+ mocks.getOrFetchDatabaseCatalog.mockResolvedValue({
+ schemas: [
+ {
+ name: "public",
+ tables: [
+ {
+ name: "salary",
+ kind: {
+ case: "columns",
+ value: {
+ columns: [{ name: "amount", semanticType: "bb.default" }],
+ },
+ },
+ },
+ ],
+ },
+ ],
+ });
+
+ const { result } = renderGuideContext({
+ enabled: true,
+ dismissed: false,
+ route: home,
+ scenarioId: "mark-sensitive-data",
+ });
+
+ await waitFor(() =>
+ expect(result.current.context.queryTarget).toEqual({
+ schema: "public",
+ table: "salary",
+ })
+ );
+ });
+
test.each([
[undefined, "instances/other/databases/selected"],
["instances/other", "instances/other/databases/selected"],
diff --git a/frontend/src/modules/workspace-setup-guide/useGuideContext.ts b/frontend/src/modules/workspace-setup-guide/useGuideContext.ts
index 5c30c86672..33872620e0 100644
--- a/frontend/src/modules/workspace-setup-guide/useGuideContext.ts
+++ b/frontend/src/modules/workspace-setup-guide/useGuideContext.ts
@@ -11,14 +11,15 @@ import { sqlEditorEvents } from "@/modules/sql-editor/model/events";
import { useAppStore } from "@/stores/app";
import { catalogResourceName } from "@/stores/app/databaseCatalog";
import { Engine, State } from "@/types/proto-es/v1/common_pb";
-import type {
- DatabaseCatalog,
- ObjectSchema,
-} from "@/types/proto-es/v1/database_catalog_service_pb";
+import type { DatabaseCatalog } from "@/types/proto-es/v1/database_catalog_service_pb";
import { getDatabaseEngine } from "@/utils/v1/database";
import { convertMemberToFullname } from "@/utils/v1/iam";
import { extractProjectResourceName } from "@/utils/v1/project";
import { GUIDE_PROGRESS_KEYS } from "./progress";
+import {
+ findGuideQueryTarget,
+ tableHasMarkedSensitiveData,
+} from "./queryTarget";
import type {
GuideContext,
GuideRoute,
@@ -43,35 +44,14 @@ const INITIAL_FACTS: GuideFacts = {
instanceName: "",
databaseProjectName: "",
databaseName: "",
-};
-
-const objectSchemaHasSemanticType = (
- schema: ObjectSchema | undefined
-): boolean => {
- if (!schema) return false;
- if (schema.semanticType) return true;
- if (schema.kind.case === "structKind") {
- return Object.values(schema.kind.value.properties).some(
- objectSchemaHasSemanticType
- );
- }
- if (schema.kind.case === "arrayKind") {
- return objectSchemaHasSemanticType(schema.kind.value.kind);
- }
- return false;
+ queryTarget: undefined,
};
export const catalogHasMarkedSensitiveData = (
catalog: Pick<DatabaseCatalog, "schemas"> | undefined
) =>
catalog?.schemas.some((schema) =>
- schema.tables.some(
- (table) =>
- (table.kind?.case === "columns" &&
- table.kind.value.columns.some((column) => !!column.semanticType)) ||
- (table.kind?.case === "objectSchema" &&
- objectSchemaHasSemanticType(table.kind.value))
- )
+ schema.tables.some(tableHasMarkedSensitiveData)
) ?? false;
export const hasOtherHumanWorkspaceMember = (
@@ -219,6 +199,18 @@ export const useGuideContext = ({
? state.catalogsByName[catalogResourceName(databaseName)]
: undefined
);
+ const targetMetadata = useAppStore((state) =>
+ databaseName ? state.getCachedDatabaseMetadata(databaseName) : undefined
+ );
+ const liveQueryTarget =
+ scenarioId === "mark-sensitive-data"
+ ? targetCatalog
+ ? findGuideQueryTarget(targetMetadata, targetCatalog)
+ : undefined
+ : findGuideQueryTarget(targetMetadata);
+ const queryTarget =
+ liveQueryTarget ??
+ (databaseName === facts.databaseName ? facts.queryTarget : undefined);
const hasMarkedSensitiveData =
sensitiveDataMarked ||
facts.hasMarkedSensitiveData ||
@@ -375,15 +367,28 @@ export const useGuideContext = ({
const database = databases?.databases.find(
({ name, project }) => !!name && !!project
);
- const catalog =
- scenarioId === "mark-sensitive-data" && database
- ? await store
- .getOrFetchDatabaseCatalog({
- database: database.name,
- silent: true,
- })
- .catch(() => undefined)
- : undefined;
+ const shouldPrepareQuery =
+ scenarioId === "query-data" || scenarioId === "mark-sensitive-data";
+ const [metadata, catalog] = database
+ ? await Promise.all([
+ shouldPrepareQuery
+ ? store
+ .getOrFetchDatabaseMetadata({
+ database: database.name,
+ silent: true,
+ })
+ .catch(() => undefined)
+ : undefined,
+ scenarioId === "mark-sensitive-data"
+ ? store
+ .getOrFetchDatabaseCatalog({
+ database: database.name,
+ silent: true,
+ })
+ .catch(() => undefined)
+ : undefined,
+ ])
+ : [];
const eventTarget = eventTargetRef.current;
setFacts((state) => ({
@@ -405,6 +410,10 @@ export const useGuideContext = ({
databaseProjectName:
eventTarget?.projectName ?? database?.project ?? "",
databaseName: eventTarget?.databaseName ?? database?.name ?? "",
+ queryTarget: findGuideQueryTarget(
+ metadata,
+ scenarioId === "mark-sensitive-data" ? catalog : undefined
+ ),
}));
} catch {
setFacts((state) => ({
@@ -440,6 +449,7 @@ export const useGuideContext = ({
...facts,
databaseName,
databaseProjectName,
+ queryTarget,
hasMarkedSensitiveData,
isSaaS,
hasOtherWorkspaceMember,
@@ -449,6 +459,7 @@ export const useGuideContext = ({
facts,
databaseName,
databaseProjectName,
+ queryTarget,
hasMarkedSensitiveData,
hasOtherWorkspaceMember,
isSaaS,