Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

GDGT-1531 - Opening a transform should open tab immediately (#69224)

Kamil Mielnik5474fca0c0a2
diff --git a/e2e/test/scenarios/data-studio/workspaces.cy.spec.ts b/e2e/test/scenarios/data-studio/workspaces.cy.spec.ts
index 980f170f6b8..24c42b1b191 100644
--- a/e2e/test/scenarios/data-studio/workspaces.cy.spec.ts
+++ b/e2e/test/scenarios/data-studio/workspaces.cy.spec.ts
@@ -1570,7 +1570,7 @@ describe("scenarios > data studio > workspaces", () => {
});
});
- describe("transform -> workspace > ", () => {
+ describe("check out transform into a workspace", () => {
it("should check out transform into a new workspace from the transform page", () => {
cy.log("Create 2 workspaces, add transform to the second one");
createTransforms();
@@ -2264,7 +2264,7 @@ describe("scenarios > data studio > workspaces", () => {
});
});
- describe("repros > ", () => {
+ describe("repros", () => {
it("should not show error when editing a new transform in a workspace (GDGT-1445)", () => {
Workspaces.visitTransformListPage();
cy.findByLabelText("Create a transform").click();
@@ -2440,6 +2440,30 @@ describe("scenarios > data studio > workspaces", () => {
"Last ran a few seconds ago successfully.",
);
});
+
+ it("should immediately open transform tab and show a loading state (GDGT-1531)", () => {
+ createTransforms();
+ Workspaces.visitWorkspaces();
+ createWorkspace();
+
+ cy.intercept("GET", "/api/transform/*", (request) => {
+ request.reply((response) => {
+ response.setDelay(2000);
+ response.send();
+ });
+ }).as("getTransform");
+
+ cy.log("Create first SQL transform that will succeed");
+ Workspaces.getMainlandTransforms().findByText("SQL transform").click();
+
+ Workspaces.getWorkspaceContent().within(() => {
+ H.tabsShouldBe("SQL transform", ["Setup", "Graph", "SQL transform"]);
+ cy.findByTestId("loading-indicator").should("be.visible");
+ });
+
+ cy.wait("@getTransform");
+ cy.findByTestId("loading-indicator").should("not.exist");
+ });
});
});
diff --git a/enterprise/frontend/src/metabase-enterprise/api/workspace.ts b/enterprise/frontend/src/metabase-enterprise/api/workspace.ts
index 7bc3eec8d99..571263c1544 100644
--- a/enterprise/frontend/src/metabase-enterprise/api/workspace.ts
+++ b/enterprise/frontend/src/metabase-enterprise/api/workspace.ts
@@ -393,7 +393,6 @@ export const {
useGetWorkspaceTransformsQuery,
useGetExternalTransformsQuery,
useGetWorkspaceTransformQuery,
- useLazyGetWorkspaceTransformQuery,
useCreateWorkspaceMutation,
useCreateWorkspaceTransformMutation,
useUpdateWorkspaceTransformMutation,
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/AddTransformMenu.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/AddTransformMenu.tsx
index 23857544b64..b486ed14ff6 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/AddTransformMenu.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/AddTransformMenu.tsx
@@ -6,7 +6,6 @@ import {
} from "metabase/transforms/pages/NewTransformPage/utils";
import { ActionIcon, Icon, Menu, Tooltip } from "metabase/ui";
import type { DatabaseId, TransformSource } from "metabase-types/api";
-import { createMockTransform } from "metabase-types/api/mocks/transform";
import { useWorkspace } from "./WorkspaceProvider";
@@ -54,11 +53,7 @@ export const AddTransformMenu = ({ databaseId, disabled }: Props) => {
<Menu.Item
leftSection={<Icon name="sql" />}
onClick={() => {
- const mockTransform = createMockTransform({
- source: getSource("sql"),
- });
-
- addUnsavedTransform(mockTransform.source);
+ addUnsavedTransform(getSource("sql"));
}}
>
{t`SQL Transform`}
@@ -66,11 +61,7 @@ export const AddTransformMenu = ({ databaseId, disabled }: Props) => {
<Menu.Item
leftSection={<Icon name="code_block" />}
onClick={() => {
- const mockTransform = createMockTransform({
- source: getSource("python"),
- });
-
- addUnsavedTransform(mockTransform.source);
+ addUnsavedTransform(getSource("python"));
}}
>
{t`Python Script`}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/CodeTab/CodeTab.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/CodeTab/CodeTab.tsx
index ce51c4a4b0a..903c5b4eea3 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/CodeTab/CodeTab.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/CodeTab/CodeTab.tsx
@@ -1,27 +1,24 @@
import { useCallback } from "react";
import { t } from "ttag";
-import { skipToken, useLazyGetTransformQuery } from "metabase/api";
+import { skipToken } from "metabase/api";
import { EmptyState } from "metabase/common/components/EmptyState";
-import { useMetadataToasts } from "metabase/metadata/hooks";
import { Stack, Text } from "metabase/ui";
-import {
- useGetExternalTransformsQuery,
- useLazyGetWorkspaceTransformQuery,
-} from "metabase-enterprise/api";
+import { useGetExternalTransformsQuery } from "metabase-enterprise/api";
import { getCheckoutDisabledMessage } from "metabase-enterprise/data-studio/workspaces/utils";
import type {
DatabaseId,
ExternalTransform,
- TaggedTransform,
UnsavedTransform,
WorkspaceId,
- WorkspaceTransform,
WorkspaceTransformListItem,
} from "metabase-types/api";
import { isUnsavedTransform } from "metabase-types/api";
-import { useWorkspace } from "../WorkspaceProvider";
+import {
+ type AnyWorkspaceTransformRef,
+ useWorkspace,
+} from "../WorkspaceProvider";
import {
TransformListItem,
@@ -48,9 +45,7 @@ type CodeTabProps = {
workspaceTransforms: WorkspaceTransformItem[];
isLoadingWorkspaceTransforms?: boolean;
readOnly: boolean;
- onTransformClick: (
- transform: TaggedTransform | WorkspaceTransform | UnsavedTransform,
- ) => void;
+ onTransformClick: (transformRef: AnyWorkspaceTransformRef) => void;
};
export const CodeTab = ({
@@ -63,7 +58,6 @@ export const CodeTab = ({
onTransformClick,
}: CodeTabProps) => {
const { editedTransforms } = useWorkspace();
- const { sendErrorToast } = useMetadataToasts();
const {
data: availableTransforms,
@@ -73,59 +67,38 @@ export const CodeTab = ({
databaseId ? { workspaceId, databaseId } : skipToken,
);
- const [fetchWorkspaceTransform] = useLazyGetWorkspaceTransformQuery();
- const [fetchTransform] = useLazyGetTransformQuery();
-
const handleExternalTransformClick = useCallback(
async (externalTransform: ExternalTransform) => {
if (externalTransform.checkout_disabled) {
return;
}
- const { data: transform, error } = await fetchTransform(
- externalTransform.id,
- true,
- );
-
- if (error) {
- sendErrorToast(t`Failed to fetch transform`);
- } else if (transform) {
- const taggedTransform: TaggedTransform = {
- ...transform,
- type: "transform",
- };
- onTransformClick(taggedTransform);
- }
+ onTransformClick({
+ type: "transform",
+ id: externalTransform.id,
+ name: externalTransform.name,
+ });
},
- [fetchTransform, onTransformClick, sendErrorToast],
+ [onTransformClick],
);
const handleWorkspaceTransformItemClick = useCallback(
async (item: WorkspaceTransformItem) => {
- // Unsaved transforms are stored locally.
- // They should open directly without API fetch.
if (isUnsavedTransform(item)) {
- // Unsaved transforms should already be opened via the provider
- // This path shouldn't normally be hit, but if it is, we can't
- // call onTransformClick because we don't have a full transform
- return onTransformClick(item);
- }
-
- const { data: transform, error } = await fetchWorkspaceTransform(
- {
- workspaceId,
- transformId: item.ref_id,
- },
- true,
- );
-
- if (error) {
- sendErrorToast(t`Failed to fetch transform`);
- } else if (transform) {
- onTransformClick(transform);
+ onTransformClick({
+ type: "unsaved-transform",
+ id: item.id,
+ name: item.name,
+ });
+ } else {
+ onTransformClick({
+ type: "workspace-transform",
+ ref_id: item.ref_id,
+ name: item.name,
+ });
}
},
- [fetchWorkspaceTransform, workspaceId, onTransformClick, sendErrorToast],
+ [onTransformClick],
);
return (
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTab.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTab.tsx
index cddb7da85f5..e1160282f8f 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTab.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTab.tsx
@@ -1,448 +1,71 @@
-import { useDisclosure } from "@mantine/hooks";
-import { useCallback, useEffect, useRef, useState } from "react";
import { t } from "ttag";
-import { useDispatch, useSelector } from "metabase/lib/redux";
-import { useMetadataToasts } from "metabase/metadata/hooks";
-import { getMetadata } from "metabase/selectors/metadata";
-import { RunStatus } from "metabase/transforms/components/RunStatus";
-import {
- getInitialNativeSource,
- getInitialPythonSource,
-} from "metabase/transforms/pages/NewTransformPage/utils";
-import { Box, Button, Group, Icon, Stack } from "metabase/ui";
-import { useDryRunWorkspaceTransformMutation } from "metabase-enterprise/api";
-import { useWorkspaceTransformRun } from "metabase-enterprise/data-studio/workspaces/hooks";
-import {
- deactivateSuggestedTransform,
- getMetabotSuggestedTransform,
-} from "metabase-enterprise/metabot/state";
-import * as Lib from "metabase-lib";
-import Question from "metabase-lib/v1/Question";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { Text } from "metabase/ui";
import type {
DatabaseId,
- DatasetQuery,
- DraftTransformSource,
TaggedTransform,
- TestPythonTransformResponse,
WorkspaceId,
WorkspaceTransform,
- WorkspaceTransformDryRunResponse,
WorkspaceTransformListItem,
} from "metabase-types/api";
-import { isUnsavedTransform, isWorkspaceTransform } from "metabase-types/api";
-import { WorkspaceRunButton } from "../../../components/WorkspaceRunButton/WorkspaceRunButton";
-import { TransformEditor } from "../TransformEditor";
-import type { AnyWorkspaceTransform, TableTab } from "../WorkspaceProvider";
-import {
- getNumericTransformId,
- getTransformId,
- useWorkspace,
-} from "../WorkspaceProvider";
+import { useWorkspace } from "../WorkspaceProvider";
+import { useActiveTransform } from "../useActiveTransform";
-import { SaveTransformButton } from "./SaveTransformButton";
-import { UpdateTargetModal } from "./UpdateTargetModal/UpdateTargetModal";
-import { useEditedTransform } from "./useEditedTransform";
+import { TransformTabContent } from "./TransformTabContent";
interface Props {
databaseId: DatabaseId;
- transform: AnyWorkspaceTransform;
+ disabled: boolean;
workspaceId: WorkspaceId;
workspaceTransforms: WorkspaceTransformListItem[];
- isDisabled: boolean;
onSaveTransform: (transform: TaggedTransform | WorkspaceTransform) => void;
}
export function TransformTab({
databaseId,
- transform,
+ disabled,
workspaceId,
workspaceTransforms,
- isDisabled,
onSaveTransform,
}: Props) {
- const {
- updateTransformState,
- addOpenedTab,
- editedTransforms,
- patchEditedTransform,
- } = useWorkspace();
- const { sendErrorToast } = useMetadataToasts();
- const [
- isChangeTargetModalOpen,
- { open: openChangeTargetModal, close: closeChangeTargetModal },
- ] = useDisclosure();
- const dispatch = useDispatch();
- const transformId = getTransformId(transform);
- const numericTransformId = getNumericTransformId(transform);
- const suggestedTransform = useSelector((state) =>
- getMetabotSuggestedTransform(state, numericTransformId),
- );
- const metadata = useSelector(getMetadata);
+ const { activeTransformRef, activeEditedTransform, unsavedTransforms } =
+ useWorkspace();
- // Local source state to prevent re-renders on every keystroke
- // This is the key optimization: we manage source locally and sync to provider
- const [localSource, setLocalSource] = useState<DraftTransformSource>(() => {
- const edited = editedTransforms.get(transformId);
- return edited?.source ?? transform.source;
+ const {
+ data: activeTransform,
+ error: activeTransformError,
+ isLoading: activeTransformIsLoading,
+ } = useActiveTransform({
+ transformRef: activeTransformRef,
+ unsavedTransforms,
+ workspaceId: workspaceId,
});
- // Track previous transform ID to detect when we switch transforms
- const prevTransformIdRef = useRef(transformId);
-
- // Reset local source when switching to a different transform
- useEffect(() => {
- if (prevTransformIdRef.current !== transformId) {
- const edited = editedTransforms.get(transformId);
- setLocalSource(edited?.source ?? transform.source);
- prevTransformIdRef.current = transformId;
- }
- // Note: editedTransforms is intentionally excluded from deps
- // We only want to sync when transform ID changes, not on every edit
- }, [transformId, transform.source, editedTransforms]);
-
- const { editedTransform, hasChanges, providerEdited } =
- useEditedTransform(transform);
-
- const wsTransform = isWorkspaceTransform(transform) ? transform : null;
- const currentSource = providerEdited?.source ?? localSource;
-
- // Run transform hook - handles run state, API calls, and error handling
- const { statusRun, buttonRun, isRunStatusLoading, isRunning, handleRun } =
- useWorkspaceTransformRun({
- workspaceId,
- transform: wsTransform,
- });
-
- const handleRunQueryStart = useCallback(
- (query: DatasetQuery) => {
- // Preview doesn't have a real table ID, but we need to provide a unique identifier
- // to open preview tab correctly.
- const tableTabId = `table-${transformId}`;
-
- // Use dry-run API to preview the saved transform's source.
- // The preview button is only shown when transform is saved and has no unsaved changes,
- // so we can safely use dry-run which executes the saved source.
- const tableTab: TableTab = {
- id: tableTabId,
- name: t`Preview (${transform.name})`,
- type: "table",
- table: {
- tableId: null,
- name: t`Preview (${transform.name})`,
- query,
- transformId: String(transformId),
- },
- };
- addOpenedTab(tableTab);
- return false;
- },
- [transformId, transform.name, addOpenedTab],
- );
-
- const handleRunTransform = useCallback(
- (result: unknown) => {
- const tableTabId = `table-${transformId}`;
-
- const tableTab: TableTab = {
- id: tableTabId,
- name: t`Preview (${transform.name})`,
- type: "table",
- table: {
- tableId: null,
- name: t`Preview (${transform.name})`,
- transformId: String(transformId),
- pythonPreviewResult: result,
- },
- };
-
- addOpenedTab(tableTab);
- },
- [transformId, transform.name, addOpenedTab],
- );
-
- // Dry-run handler for Python transforms
- const [dryRunTransform] = useDryRunWorkspaceTransformMutation();
-
- const handlePythonRun = useCallback(async () => {
- if (!wsTransform) {
- return;
- }
-
- try {
- const result = await dryRunTransform({
- workspaceId,
- transformId: wsTransform.ref_id,
- }).unwrap();
-
- // Convert dry-run response to TestPythonTransformResponse format
- const converted = convertDryRunToTestResponse(result);
- handleRunTransform(converted);
- } catch (error) {
- // Handle error - show in preview results
- const errorResult: TestPythonTransformResponse = {
- error: {
- message:
- error instanceof Error ? error.message : "Transform preview failed",
- },
- };
- handleRunTransform(errorResult);
- }
- }, [wsTransform, workspaceId, dryRunTransform, handleRunTransform]);
-
- const normalizeSource = useCallback(
- (source: DraftTransformSource): DraftTransformSource => {
- if (source.type !== "query") {
- return source;
- }
-
- const question = Question.create({
- dataset_query: source.query,
- metadata,
- });
- const query = question.query();
- const { isNative } = Lib.queryDisplayInfo(query);
- const normalizedQuery = isNative
- ? Lib.withNativeQuery(query, Lib.rawNativeQuery(query))
- : query;
-
- return {
- type: "query" as const,
- query: question.setQuery(normalizedQuery).datasetQuery(),
- };
- },
- [metadata],
- );
-
- // Show proposed source when there's an active suggested transform
- // Even if sources are the same (e.g., when transform was created with suggested source),
- // we still want to show the buttons so user can reject the suggestion
- const proposedSource: DraftTransformSource | undefined =
- suggestedTransform?.source
- ? normalizeSource(suggestedTransform.source)
- : undefined;
-
- const isSaved =
- isWorkspaceTransform(transform) &&
- workspaceTransforms.some((t) => t.ref_id === transform.ref_id);
- const isEditable = !isDisabled;
-
- const handleSourceChange = useCallback(
- (source: DraftTransformSource) => {
- setLocalSource(source);
- patchEditedTransform(transformId, { source });
- },
- [transformId, patchEditedTransform],
- );
-
- const handleMetabotAcceptProposed = useCallback(() => {
- if (proposedSource == null) {
- return;
- }
-
- // Allow applying suggestions to both saved workspace transforms and unsaved transforms
- // Only block if it's a tagged transform (external transform) that hasn't been checked out
- const isUnsaved = isUnsavedTransform(transform);
- if (!isSaved && !isUnsaved) {
- sendErrorToast(
- t`Add this transform to the workspace before applying Metabot changes.`,
- );
- return;
- }
-
- // When accepting, we DO need to update localSource to reset the editor
- setLocalSource(proposedSource);
- patchEditedTransform(transformId, { source: proposedSource });
- dispatch(deactivateSuggestedTransform(suggestedTransform?.id));
- }, [
- proposedSource,
- dispatch,
- suggestedTransform?.id,
- isSaved,
- transform,
- sendErrorToast,
- transformId,
- patchEditedTransform,
- ]);
-
- const handleMetabotRejectProposed = useCallback(() => {
- if (suggestedTransform) {
- dispatch(deactivateSuggestedTransform(suggestedTransform.id));
-
- // For unsaved transforms, clear the source back to empty state when rejecting
- if (isUnsavedTransform(transform)) {
- const emptySource = createEmptySourceForType(currentSource);
- if (emptySource) {
- // When rejecting, we DO need to update localSource to reset the editor
- setLocalSource(emptySource);
- patchEditedTransform(transformId, { source: emptySource });
- }
- }
- }
- }, [
- dispatch,
- suggestedTransform,
- transform,
- currentSource,
- transformId,
- patchEditedTransform,
- ]);
-
- const handleTargetUpdate = useCallback(
- (updatedTransform?: WorkspaceTransform) => {
- if (updatedTransform) {
- updateTransformState(updatedTransform);
- }
- closeChangeTargetModal();
- },
- [updateTransformState, closeChangeTargetModal],
- );
-
- return (
- <Stack gap={0} h="100%">
- <Stack
- data-testid="transform-tab-header"
- flex="0 0 auto"
- gap="sm"
- p="md"
- style={{ borderBottom: "1px solid var(--mb-color-border)" }}
- >
- <Group justify="space-between">
- <Group>
- {isSaved && (
- <Button
- leftSection={<Icon name="pencil_lines" />}
- size="sm"
- disabled={isRunning || hasChanges || isDisabled}
- onClick={openChangeTargetModal}
- >{t`Change target`}</Button>
- )}
- </Group>
-
- <Group>
- {isSaved && (
- <WorkspaceRunButton
- id={numericTransformId}
- run={buttonRun}
- isDisabled={hasChanges || isDisabled}
- onRun={handleRun}
- />
- )}
-
- <SaveTransformButton
- databaseId={databaseId}
- workspaceId={workspaceId}
- workspaceTransforms={workspaceTransforms}
- transform={transform}
- isDisabled={isDisabled}
- onSaveTransform={onSaveTransform}
- />
- </Group>
- </Group>
-
- {isSaved &&
- (isRunStatusLoading ? (
- <Group gap="sm">
- <Icon c="text-secondary" name="sync" />
- <Box>{t`Loading run status...`}</Box>
- </Group>
- ) : (
- <RunStatus
- run={statusRun}
- neverRunMessage={t`This transform hasn't been run before.`}
- />
- ))}
- </Stack>
-
- {editedTransform && (
- <Box
- flex="1 1 auto"
- style={{ overflow: "auto", "--native-query-editor-flex": "1 1 auto" }}
- >
- <TransformEditor
- disabled={!isEditable}
- hideRunButton={!isSaved || hasChanges}
- source={localSource}
- proposedSource={proposedSource}
- onAcceptProposed={handleMetabotAcceptProposed}
- onRejectProposed={handleMetabotRejectProposed}
- onChange={handleSourceChange}
- onRunQueryStart={handleRunQueryStart}
- onRunTransform={handleRunTransform}
- onRun={handlePythonRun}
- />
- </Box>
- )}
-
- {isChangeTargetModalOpen && wsTransform && (
- <UpdateTargetModal
- transform={wsTransform}
- onUpdate={handleTargetUpdate}
- onClose={closeChangeTargetModal}
- />
- )}
- </Stack>
- );
-}
-
-/**
- * Creates an empty source based on the type of the current source.
- * Used when rejecting a metabot suggestion on an unsaved transform.
- */
-function createEmptySourceForType(
- currentSource: DraftTransformSource,
-): DraftTransformSource | null {
- if (currentSource.type === "query") {
- const emptySource = getInitialNativeSource();
- // Preserve the database ID from the current source
- const databaseId =
- "database" in currentSource.query ? currentSource.query.database : null;
- if (databaseId) {
- return {
- ...emptySource,
- query: { ...emptySource.query, database: databaseId },
- };
- }
- return emptySource;
+ if (activeTransformError || activeTransformIsLoading) {
+ return (
+ <LoadingAndErrorWrapper
+ error={activeTransformError}
+ loading={activeTransformIsLoading}
+ />
+ );
}
- if (currentSource.type === "python") {
- const emptySource = getInitialPythonSource();
- // Preserve the database ID from the current source
- return {
- ...emptySource,
- "source-database": currentSource["source-database"],
- };
+ if (!activeEditedTransform || !activeTransform) {
+ return (
+ <Text c="text-secondary">{t`Select a transform on the right.`}</Text>
+ );
}
- return null;
-}
-
-/**
- * Converts a dry-run response to the TestPythonTransformResponse format
- * expected by PythonEditorResults component.
- */
-function convertDryRunToTestResponse(
- dryRun: WorkspaceTransformDryRunResponse,
-): TestPythonTransformResponse {
- if (dryRun.status === "failed") {
- return {
- error: { message: dryRun.message ?? "Transform failed" },
- logs: dryRun.logs ?? "",
- };
- }
-
- const cols = (dryRun.data?.cols ?? []).map((col) => ({
- name: col.name ?? "",
- }));
- // Convert rows from array format [[val1, val2], ...] to object format [{col1: val1, col2: val2}, ...]
- const rows = (dryRun.data?.rows ?? []).map((row) =>
- Object.fromEntries(cols.map((col, i) => [col.name, row[i]])),
+ return (
+ <TransformTabContent
+ databaseId={databaseId}
+ disabled={disabled}
+ transform={activeTransform}
+ workspaceId={workspaceId}
+ workspaceTransforms={workspaceTransforms}
+ onSaveTransform={onSaveTransform}
+ />
);
-
- return {
- logs: dryRun.logs ?? "",
- output: { cols, rows },
- };
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTabContent.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTabContent.tsx
new file mode 100644
index 00000000000..91ee1f9555e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/TransformTab/TransformTabContent.tsx
@@ -0,0 +1,448 @@
+import { useDisclosure } from "@mantine/hooks";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { t } from "ttag";
+
+import { useDispatch, useSelector } from "metabase/lib/redux";
+import { useMetadataToasts } from "metabase/metadata/hooks";
+import { getMetadata } from "metabase/selectors/metadata";
+import { RunStatus } from "metabase/transforms/components/RunStatus";
+import {
+ getInitialNativeSource,
+ getInitialPythonSource,
+} from "metabase/transforms/pages/NewTransformPage/utils";
+import { Box, Button, Group, Icon, Stack } from "metabase/ui";
+import { useDryRunWorkspaceTransformMutation } from "metabase-enterprise/api";
+import { useWorkspaceTransformRun } from "metabase-enterprise/data-studio/workspaces/hooks";
+import {
+ deactivateSuggestedTransform,
+ getMetabotSuggestedTransform,
+} from "metabase-enterprise/metabot/state";
+import * as Lib from "metabase-lib";
+import Question from "metabase-lib/v1/Question";
+import type {
+ DatabaseId,
+ DatasetQuery,
+ DraftTransformSource,
+ TaggedTransform,
+ TestPythonTransformResponse,
+ WorkspaceId,
+ WorkspaceTransform,
+ WorkspaceTransformDryRunResponse,
+ WorkspaceTransformListItem,
+} from "metabase-types/api";
+import { isUnsavedTransform, isWorkspaceTransform } from "metabase-types/api";
+
+import { WorkspaceRunButton } from "../../../components/WorkspaceRunButton/WorkspaceRunButton";
+import { TransformEditor } from "../TransformEditor";
+import type { AnyWorkspaceTransform, TableTab } from "../WorkspaceProvider";
+import {
+ getNumericTransformId,
+ getTransformId,
+ useWorkspace,
+} from "../WorkspaceProvider";
+
+import { SaveTransformButton } from "./SaveTransformButton";
+import { UpdateTargetModal } from "./UpdateTargetModal/UpdateTargetModal";
+import { useEditedTransform } from "./useEditedTransform";
+
+interface Props {
+ databaseId: DatabaseId;
+ transform: AnyWorkspaceTransform;
+ workspaceId: WorkspaceId;
+ workspaceTransforms: WorkspaceTransformListItem[];
+ disabled: boolean;
+ onSaveTransform: (transform: TaggedTransform | WorkspaceTransform) => void;
+}
+
+export function TransformTabContent({
+ databaseId,
+ transform,
+ workspaceId,
+ workspaceTransforms,
+ disabled,
+ onSaveTransform,
+}: Props) {
+ const {
+ updateTransformState,
+ addOpenedTab,
+ editedTransforms,
+ patchEditedTransform,
+ } = useWorkspace();
+ const { sendErrorToast } = useMetadataToasts();
+ const [
+ isChangeTargetModalOpen,
+ { open: openChangeTargetModal, close: closeChangeTargetModal },
+ ] = useDisclosure();
+ const dispatch = useDispatch();
+ const transformId = getTransformId(transform);
+ const numericTransformId = getNumericTransformId(transform);
+ const suggestedTransform = useSelector((state) =>
+ getMetabotSuggestedTransform(state, numericTransformId),
+ );
+ const metadata = useSelector(getMetadata);
+
+ // Local source state to prevent re-renders on every keystroke
+ // This is the key optimization: we manage source locally and sync to provider
+ const [localSource, setLocalSource] = useState<DraftTransformSource>(() => {
+ const edited = editedTransforms.get(transformId);
+ return edited?.source ?? transform.source;
+ });
+
+ // Track previous transform ID to detect when we switch transforms
+ const prevTransformIdRef = useRef(transformId);
+
+ // Reset local source when switching to a different transform
+ useEffect(() => {
+ if (prevTransformIdRef.current !== transformId) {
+ const edited = editedTransforms.get(transformId);
+ setLocalSource(edited?.source ?? transform.source);
+ prevTransformIdRef.current = transformId;
+ }
+ // Note: editedTransforms is intentionally excluded from deps
+ // We only want to sync when transform ID changes, not on every edit
+ }, [transformId, transform.source, editedTransforms]);
+
+ const { editedTransform, hasChanges, providerEdited } =
+ useEditedTransform(transform);
+
+ const wsTransform = isWorkspaceTransform(transform) ? transform : null;
+ const currentSource = providerEdited?.source ?? localSource;
+
+ // Run transform hook - handles run state, API calls, and error handling
+ const { statusRun, buttonRun, isRunStatusLoading, isRunning, handleRun } =
+ useWorkspaceTransformRun({
+ workspaceId,
+ transform: wsTransform,
+ });
+
+ const handleRunQueryStart = useCallback(
+ (query: DatasetQuery) => {
+ // Preview doesn't have a real table ID, but we need to provide a unique identifier
+ // to open preview tab correctly.
+ const tableTabId = `table-${transformId}`;
+
+ // Use dry-run API to preview the saved transform's source.
+ // The preview button is only shown when transform is saved and has no unsaved changes,
+ // so we can safely use dry-run which executes the saved source.
+ const tableTab: TableTab = {
+ id: tableTabId,
+ name: t`Preview (${transform.name})`,
+ type: "table",
+ table: {
+ tableId: null,
+ name: t`Preview (${transform.name})`,
+ query,
+ transformId: String(transformId),
+ },
+ };
+ addOpenedTab(tableTab);
+ return false;
+ },
+ [transformId, transform.name, addOpenedTab],
+ );
+
+ const handleRunTransform = useCallback(
+ (result: unknown) => {
+ const tableTabId = `table-${transformId}`;
+
+ const tableTab: TableTab = {
+ id: tableTabId,
+ name: t`Preview (${transform.name})`,
+ type: "table",
+ table: {
+ tableId: null,
+ name: t`Preview (${transform.name})`,
+ transformId: String(transformId),
+ pythonPreviewResult: result,
+ },
+ };
+
+ addOpenedTab(tableTab);
+ },
+ [transformId, transform.name, addOpenedTab],
+ );
+
+ // Dry-run handler for Python transforms
+ const [dryRunTransform] = useDryRunWorkspaceTransformMutation();
+
+ const handlePythonRun = useCallback(async () => {
+ if (!wsTransform) {
+ return;
+ }
+
+ try {
+ const result = await dryRunTransform({
+ workspaceId,
+ transformId: wsTransform.ref_id,
+ }).unwrap();
+
+ // Convert dry-run response to TestPythonTransformResponse format
+ const converted = convertDryRunToTestResponse(result);
+ handleRunTransform(converted);
+ } catch (error) {
+ // Handle error - show in preview results
+ const errorResult: TestPythonTransformResponse = {
+ error: {
+ message:
+ error instanceof Error ? error.message : "Transform preview failed",
+ },
+ };
+ handleRunTransform(errorResult);
+ }
+ }, [wsTransform, workspaceId, dryRunTransform, handleRunTransform]);
+
+ const normalizeSource = useCallback(
+ (source: DraftTransformSource): DraftTransformSource => {
+ if (source.type !== "query") {
+ return source;
+ }
+
+ const question = Question.create({
+ dataset_query: source.query,
+ metadata,
+ });
+ const query = question.query();
+ const { isNative } = Lib.queryDisplayInfo(query);
+ const normalizedQuery = isNative
+ ? Lib.withNativeQuery(query, Lib.rawNativeQuery(query))
+ : query;
+
+ return {
+ type: "query" as const,
+ query: question.setQuery(normalizedQuery).datasetQuery(),
+ };
+ },
+ [metadata],
+ );
+
+ // Show proposed source when there's an active suggested transform
+ // Even if sources are the same (e.g., when transform was created with suggested source),
+ // we still want to show the buttons so user can reject the suggestion
+ const proposedSource: DraftTransformSource | undefined =
+ suggestedTransform?.source
+ ? normalizeSource(suggestedTransform.source)
+ : undefined;
+
+ const isSaved =
+ isWorkspaceTransform(transform) &&
+ workspaceTransforms.some((t) => t.ref_id === transform.ref_id);
+ const isEditable = !disabled;
+
+ const handleSourceChange = useCallback(
+ (source: DraftTransformSource) => {
+ setLocalSource(source);
+ patchEditedTransform(transformId, { source });
+ },
+ [transformId, patchEditedTransform],
+ );
+
+ const handleMetabotAcceptProposed = useCallback(() => {
+ if (proposedSource == null) {
+ return;
+ }
+
+ // Allow applying suggestions to both saved workspace transforms and unsaved transforms
+ // Only block if it's a tagged transform (external transform) that hasn't been checked out
+ const isUnsaved = isUnsavedTransform(transform);
+ if (!isSaved && !isUnsaved) {
+ sendErrorToast(
+ t`Add this transform to the workspace before applying Metabot changes.`,
+ );
+ return;
+ }
+
+ // When accepting, we DO need to update localSource to reset the editor
+ setLocalSource(proposedSource);
+ patchEditedTransform(transformId, { source: proposedSource });
+ dispatch(deactivateSuggestedTransform(suggestedTransform?.id));
+ }, [
+ proposedSource,
+ dispatch,
+ suggestedTransform?.id,
+ isSaved,
+ transform,
+ sendErrorToast,
+ transformId,
+ patchEditedTransform,
+ ]);
+
+ const handleMetabotRejectProposed = useCallback(() => {
+ if (suggestedTransform) {
+ dispatch(deactivateSuggestedTransform(suggestedTransform.id));
+
+ // For unsaved transforms, clear the source back to empty state when rejecting
+ if (isUnsavedTransform(transform)) {
+ const emptySource = createEmptySourceForType(currentSource);
+ if (emptySource) {
+ // When rejecting, we DO need to update localSource to reset the editor
+ setLocalSource(emptySource);
+ patchEditedTransform(transformId, { source: emptySource });
+ }
+ }
+ }
+ }, [
+ dispatch,
+ suggestedTransform,
+ transform,
+ currentSource,
+ transformId,
+ patchEditedTransform,
+ ]);
+
+ const handleTargetUpdate = useCallback(
+ (updatedTransform?: WorkspaceTransform) => {
+ if (updatedTransform) {
+ updateTransformState(updatedTransform);
+ }
+ closeChangeTargetModal();
+ },
+ [updateTransformState, closeChangeTargetModal],
+ );
+
+ return (
+ <Stack gap={0} h="100%">
+ <Stack
+ data-testid="transform-tab-header"
+ flex="0 0 auto"
+ gap="sm"
+ p="md"
+ style={{ borderBottom: "1px solid var(--mb-color-border)" }}
+ >
+ <Group justify="space-between">
+ <Group>
+ {isSaved && (
+ <Button
+ leftSection={<Icon name="pencil_lines" />}
+ size="sm"
+ disabled={isRunning || hasChanges || disabled}
+ onClick={openChangeTargetModal}
+ >{t`Change target`}</Button>
+ )}
+ </Group>
+
+ <Group>
+ {isSaved && (
+ <WorkspaceRunButton
+ id={numericTransformId}
+ run={buttonRun}
+ isDisabled={hasChanges || disabled}
+ onRun={handleRun}
+ />
+ )}
+
+ <SaveTransformButton
+ databaseId={databaseId}
+ workspaceId={workspaceId}
+ workspaceTransforms={workspaceTransforms}
+ transform={transform}
+ isDisabled={disabled}
+ onSaveTransform={onSaveTransform}
+ />
+ </Group>
+ </Group>
+
+ {isSaved &&
+ (isRunStatusLoading ? (
+ <Group gap="sm">
+ <Icon c="text-secondary" name="sync" />
+ <Box>{t`Loading run status...`}</Box>
+ </Group>
+ ) : (
+ <RunStatus
+ run={statusRun}
+ neverRunMessage={t`This transform hasn't been run before.`}
+ />
+ ))}
+ </Stack>
+
+ {editedTransform && (
+ <Box
+ flex="1 1 auto"
+ style={{ overflow: "auto", "--native-query-editor-flex": "1 1 auto" }}
+ >
+ <TransformEditor
+ disabled={!isEditable}
+ hideRunButton={!isSaved || hasChanges}
+ source={localSource}
+ proposedSource={proposedSource}
+ onAcceptProposed={handleMetabotAcceptProposed}
+ onRejectProposed={handleMetabotRejectProposed}
+ onChange={handleSourceChange}
+ onRunQueryStart={handleRunQueryStart}
+ onRunTransform={handleRunTransform}
+ onRun={handlePythonRun}
+ />
+ </Box>
+ )}
+
+ {isChangeTargetModalOpen && wsTransform && (
+ <UpdateTargetModal
+ transform={wsTransform}
+ onUpdate={handleTargetUpdate}
+ onClose={closeChangeTargetModal}
+ />
+ )}
+ </Stack>
+ );
+}
+
+/**
+ * Creates an empty source based on the type of the current source.
+ * Used when rejecting a metabot suggestion on an unsaved transform.
+ */
+function createEmptySourceForType(
+ currentSource: DraftTransformSource,
+): DraftTransformSource | null {
+ if (currentSource.type === "query") {
+ const emptySource = getInitialNativeSource();
+ // Preserve the database ID from the current source
+ const databaseId =
+ "database" in currentSource.query ? currentSource.query.database : null;
+ if (databaseId) {
+ return {
+ ...emptySource,
+ query: { ...emptySource.query, database: databaseId },
+ };
+ }
+ return emptySource;
+ }
+
+ if (currentSource.type === "python") {
+ const emptySource = getInitialPythonSource();
+ // Preserve the database ID from the current source
+ return {
+ ...emptySource,
+ "source-database": currentSource["source-database"],
+ };
+ }
+
+ return null;
+}
+
+/**
+ * Converts a dry-run response to the TestPythonTransformResponse format
+ * expected by PythonEditorResults component.
+ */
+function convertDryRunToTestResponse(
+ dryRun: WorkspaceTransformDryRunResponse,
+): TestPythonTransformResponse {
+ if (dryRun.status === "failed") {
+ return {
+ error: { message: dryRun.message ?? "Transform failed" },
+ logs: dryRun.logs ?? "",
+ };
+ }
+
+ const cols = (dryRun.data?.cols ?? []).map((col) => ({
+ name: col.name ?? "",
+ }));
+ // Convert rows from array format [[val1, val2], ...] to object format [{col1: val1, col2: val2}, ...]
+ const rows = (dryRun.data?.rows ?? []).map((row) =>
+ Object.fromEntries(cols.map((col, i) => [col.name, row[i]])),
+ );
+
+ return {
+ logs: dryRun.logs ?? "",
+ output: { cols, rows },
+ };
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspacePage.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspacePage.tsx
index 0091c8dbe5a..33949c60efb 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspacePage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspacePage.tsx
@@ -36,7 +36,6 @@ import {
Icon,
Stack,
Tabs,
- Text,
} from "metabase/ui";
import { MergeWorkspaceModal } from "metabase-enterprise/data-studio/workspaces/components/MergeWorkspaceModal/MergeWorkspaceModal";
import { RunWorkspaceMenu } from "metabase-enterprise/data-studio/workspaces/components/RunWorkspaceMenu/RunWorkspaceMenu";
@@ -79,16 +78,16 @@ function WorkspacePageContent({
activationConstraint: { distance: 10 },
});
const dispatch = useDispatch();
+ const workspaceId = parseInt(params.workspaceId, 10);
const {
openedTabs,
- activeTransform,
- activeEditedTransform,
+ activeTransformRef,
activeTable,
activeTab,
setActiveTab,
setActiveTable,
- setActiveTransform,
+ setActiveTransformRef,
removeOpenedTab,
setOpenedTabs,
addOpenedTransform,
@@ -101,8 +100,6 @@ function WorkspacePageContent({
const { tab, setTab, ref: tabsListRef } = useWorkspaceUiTabs();
- const workspaceId = parseInt(params.workspaceId, 10);
-
// Data fetching
const {
workspace,
@@ -163,8 +160,9 @@ function WorkspacePageContent({
const isActive =
(tab.type === "transform" &&
- activeTransform &&
- getTransformId(activeTransform) === getTransformId(tab.transform)) ||
+ activeTransformRef &&
+ getTransformId(activeTransformRef) ===
+ getTransformId(tab.transformRef)) ||
(tab.type === "table" && activeTable?.tableId === tab.table.tableId);
const remaining = openedTabs.filter((item) => item.id !== tab.id);
@@ -186,7 +184,7 @@ function WorkspacePageContent({
}
},
[
- activeTransform,
+ activeTransformRef,
activeTable,
removeOpenedTab,
setActiveTab,
@@ -427,35 +425,29 @@ function WorkspacePageContent({
</Tabs.Panel>
)}
- {activeTransform && (
+ {activeTransformRef && (
<Tabs.Panel
- value={getTransformTabId(activeTransform)}
+ value={getTransformTabId(activeTransformRef)}
h="100%"
style={{ overflow: "auto" }}
>
- {!activeEditedTransform ? (
- <Text c="text-secondary">
- {t`Select a transform on the right.`}
- </Text>
- ) : (
- <TransformTab
- databaseId={checkNotNull(workspace.database_id)}
- transform={activeTransform}
- workspaceId={workspaceId}
- workspaceTransforms={workspaceTransforms}
- isDisabled={isArchived || isPending}
- onSaveTransform={(transform) => {
- // After adding first transform to a workspace,
- // show 'Setup' tab with initialization status log.
- if (isWorkspaceUninitialized(workspace)) {
- setActiveTransform(transform);
- return setTab("setup");
- }
- setActiveTransform(transform);
+ <TransformTab
+ databaseId={checkNotNull(workspace.database_id)}
+ disabled={isArchived || isPending}
+ workspaceId={workspaceId}
+ workspaceTransforms={workspaceTransforms}
+ onSaveTransform={(transform) => {
+ // After adding first transform to a workspace,
+ // show 'Setup' tab with initialization status log.
+ if (isWorkspaceUninitialized(workspace)) {
+ setActiveTransformRef(transform);
+ setTab("setup");
+ } else {
+ setActiveTransformRef(transform);
setTab(getTransformTabId(transform));
- }}
- />
- )}
+ }
+ }}
+ />
</Tabs.Panel>
)}
</Box>
@@ -496,17 +488,17 @@ function WorkspacePageContent({
<CodeTab
readOnly={isArchived || isPending}
activeTransformId={
- activeTransform
- ? getTransformId(activeTransform)
+ activeTransformRef
+ ? getTransformId(activeTransformRef)
: undefined
}
databaseId={databaseId}
workspaceId={workspace.id}
workspaceTransforms={allTransforms}
isLoadingWorkspaceTransforms={isLoadingWorkspaceTransforms}
- onTransformClick={(transform) => {
- addOpenedTransform(transform);
- setTab(getTransformTabId(transform));
+ onTransformClick={(transformRef) => {
+ addOpenedTransform(transformRef);
+ setTab(getTransformTabId(transformRef));
if (activeTable) {
setActiveTable(null);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspaceProvider.tsx b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspaceProvider.tsx
index 0c4a16da21b..d48e86c9e1f 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspaceProvider.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/WorkspaceProvider.tsx
@@ -3,11 +3,12 @@ import {
createContext,
useCallback,
useContext,
+ useEffect,
useMemo,
useState,
} from "react";
+import { t } from "ttag";
-import { checkNotNull } from "metabase/lib/types";
import { isSameSource } from "metabase/transforms/utils";
import type {
DatasetQuery,
@@ -16,10 +17,13 @@ import type {
TaggedTransform,
TransformTargetType,
UnsavedTransform,
+ WorkspaceId,
WorkspaceTransform,
} from "metabase-types/api";
import { isUnsavedTransform, isWorkspaceTransform } from "metabase-types/api";
+import { useActiveTransform } from "./useActiveTransform";
+
export interface OpenTable {
tableId: TableId | null;
name: string;
@@ -45,6 +49,11 @@ export type AnyWorkspaceTransform =
| WorkspaceTransform
| UnsavedTransform;
+export type AnyWorkspaceTransformRef =
+ | Pick<TaggedTransform, "id" | "type" | "name">
+ | Pick<WorkspaceTransform, "ref_id" | "type" | "name">
+ | Pick<UnsavedTransform, "id" | "type" | "name">;
+
export interface Tab {
id: string;
name: string;
@@ -53,7 +62,7 @@ export interface Tab {
export interface TransformTab extends Tab {
type: "transform";
- transform: AnyWorkspaceTransform;
+ transformRef: AnyWorkspaceTransformRef;
}
export interface TableTab extends Tab {
@@ -64,21 +73,19 @@ export interface TableTab extends Tab {
export type WorkspaceTab = TransformTab | TableTab;
export interface WorkspaceContextValue {
- workspaceId: number;
+ workspaceId: WorkspaceId;
openedTabs: WorkspaceTab[];
activeTab: WorkspaceTab | null;
activeTable: OpenTable | null;
- activeTransform: AnyWorkspaceTransform | null;
+ activeTransformRef: AnyWorkspaceTransformRef | null;
activeEditedTransform?: EditedTransform | null;
setActiveTab: (tab: WorkspaceTab | null) => void;
- setActiveTransform: (transform: AnyWorkspaceTransform) => void;
+ setActiveTransformRef: (transformRef: AnyWorkspaceTransformRef) => void;
setActiveTable: (table: OpenTable | null) => void;
addOpenedTab: (tab: WorkspaceTab, activate?: boolean) => void;
removeOpenedTab: (tabId: string) => void;
setOpenedTabs: (tabs: WorkspaceTab[]) => void;
- addOpenedTransform: (
- transform: TaggedTransform | WorkspaceTransform | UnsavedTransform,
- ) => void;
+ addOpenedTransform: (transformRef: AnyWorkspaceTransformRef) => void;
removeWorkspaceTransform: (transformId: string | number) => void;
editedTransforms: Map<number | string, EditedTransform>;
patchEditedTransform: (
@@ -103,7 +110,7 @@ interface WorkspaceState {
openedTabs: WorkspaceTab[];
activeTab: WorkspaceTab | null;
activeTable: OpenTable | null;
- activeTransform: AnyWorkspaceTransform | null;
+ activeTransformRef: AnyWorkspaceTransformRef | null;
activeEditedTransform?: AnyWorkspaceTransform | null;
editedTransforms: Map<number | string, EditedTransform>;
unsavedTransforms: UnsavedTransform[];
@@ -117,17 +124,19 @@ interface WorkspaceProviderProps {
/** Get the unique identifier used for tabs and transform lookups */
export function getTransformId(
- transform: AnyWorkspaceTransform,
+ transformRef: AnyWorkspaceTransformRef,
): string | number {
- if (isWorkspaceTransform(transform)) {
- return transform.ref_id;
+ if (transformRef.type === "workspace-transform") {
+ return transformRef.ref_id;
}
- return transform.id;
+ return transformRef.id;
}
/** Get the tab ID for a transform */
-export function getTransformTabId(transform: AnyWorkspaceTransform): string {
- return `transform-${getTransformId(transform)}`;
+export function getTransformTabId(
+ transformRef: AnyWorkspaceTransformRef,
+): string {
+ return `transform-${getTransformId(transformRef)}`;
}
/** Get the numeric transform ID (for metabot, RunButton, etc.) */
@@ -142,7 +151,7 @@ export function getNumericTransformId(
const createEmptyWorkspaceState = (): WorkspaceState => ({
openedTabs: [],
- activeTransform: null,
+ activeTransformRef: null,
activeTable: null,
activeTab: null,
editedTransforms: new Map<number | string, EditedTransform>(),
@@ -155,19 +164,34 @@ export const WorkspaceProvider = ({
workspaceId,
}: WorkspaceProviderProps) => {
const [workspaceStates, setWorkspaceStates] = useState<
- Map<number, WorkspaceState>
+ Map<WorkspaceId, WorkspaceState>
>(new Map());
+
const currentState = useMemo(() => {
- const existing = workspaceStates.get(workspaceId);
- if (existing) {
- return existing;
- }
- const newState = createEmptyWorkspaceState();
- setWorkspaceStates((prev) => new Map(prev).set(workspaceId, newState));
- return newState;
+ return workspaceStates.get(workspaceId) ?? createEmptyWorkspaceState();
}, [workspaceId, workspaceStates]);
- const { openedTabs, activeTransform, activeTable, activeTab } = currentState;
+ useEffect(() => {
+ setWorkspaceStates((previous) => {
+ return previous.has(workspaceId)
+ ? previous
+ : new Map(previous).set(workspaceId, currentState);
+ });
+ }, [currentState, workspaceId]);
+
+ const {
+ openedTabs,
+ activeTransformRef,
+ activeTable,
+ activeTab,
+ unsavedTransforms,
+ } = currentState;
+
+ const { data: activeTransform } = useActiveTransform({
+ transformRef: activeTransformRef,
+ unsavedTransforms,
+ workspaceId,
+ });
const updateWorkspaceState = useCallback(
(updater: (state: WorkspaceState) => WorkspaceState) => {
@@ -185,24 +209,24 @@ export const WorkspaceProvider = ({
(tab: WorkspaceTab | null) => {
updateWorkspaceState((state) => {
const newActiveTab = tab;
- let newActiveTransform = state.activeTransform;
+ let newActiveTransformRef = state.activeTransformRef;
let newActiveTable = state.activeTable;
if (tab?.type === "transform") {
- newActiveTransform = tab.transform;
+ newActiveTransformRef = tab.transformRef;
newActiveTable = null;
} else if (tab?.type === "table") {
newActiveTable = tab.table;
- newActiveTransform = null;
+ newActiveTransformRef = null;
} else {
- newActiveTransform = null;
+ newActiveTransformRef = null;
newActiveTable = null;
}
return {
...state,
activeTab: newActiveTab,
- activeTransform: newActiveTransform,
+ activeTransformRef: newActiveTransformRef,
activeTable: newActiveTable,
};
});
@@ -221,8 +245,10 @@ export const WorkspaceProvider = ({
item.id === tab.id ? tab : item,
),
activeTab: tab,
- activeTransform:
- tab.type === "transform" ? tab.transform : state.activeTransform,
+ activeTransformRef:
+ tab.type === "transform"
+ ? tab.transformRef
+ : state.activeTransformRef,
activeTable: tab.type === "table" ? tab.table : state.activeTable,
};
}
@@ -232,8 +258,10 @@ export const WorkspaceProvider = ({
...state,
openedTabs: newOpenedTabs,
activeTab: tab,
- activeTransform:
- tab.type === "transform" ? tab.transform : state.activeTransform,
+ activeTransformRef:
+ tab.type === "transform"
+ ? tab.transformRef
+ : state.activeTransformRef,
activeTable: tab.type === "table" ? tab.table : state.activeTable,
};
});
@@ -252,7 +280,7 @@ export const WorkspaceProvider = ({
const wasActive = state.activeTab?.id === tabId;
let newActiveTab = state.activeTab;
- let newActiveTransform = state.activeTransform;
+ let newActiveTransformRef = state.activeTransformRef;
let newActiveTable = state.activeTable;
if (wasActive && removedTab) {
@@ -267,13 +295,15 @@ export const WorkspaceProvider = ({
if (fallbackTab) {
newActiveTab = fallbackTab;
- newActiveTransform =
- fallbackTab.type === "transform" ? fallbackTab.transform : null;
+ newActiveTransformRef =
+ fallbackTab.type === "transform"
+ ? fallbackTab.transformRef
+ : null;
newActiveTable =
fallbackTab.type === "table" ? fallbackTab.table : null;
} else {
newActiveTab = null;
- newActiveTransform = null;
+ newActiveTransformRef = null;
newActiveTable = null;
}
}
@@ -282,7 +312,7 @@ export const WorkspaceProvider = ({
...state,
openedTabs: filteredTabs,
activeTab: newActiveTab,
- activeTransform: newActiveTransform,
+ activeTransformRef: newActiveTransformRef,
activeTable: newActiveTable,
};
});
@@ -300,10 +330,10 @@ export const WorkspaceProvider = ({
[updateWorkspaceState],
);
- const setActiveTransform = useCallback(
- (transform: AnyWorkspaceTransform) => {
+ const setActiveTransformRef = useCallback(
+ (transformRef: AnyWorkspaceTransformRef) => {
updateWorkspaceState((state) => {
- const transformTabId = getTransformTabId(transform);
+ const transformTabId = getTransformTabId(transformRef);
const existingTab = state.openedTabs.find(
(tab) => tab.type === "transform" && tab.id === transformTabId,
);
@@ -312,22 +342,22 @@ export const WorkspaceProvider = ({
return {
...state,
activeTab: existingTab,
- activeTransform: transform,
+ activeTransformRef: transformRef,
activeTable: null,
};
} else {
const newTransformTab: TransformTab = {
id: transformTabId,
- name: transform.name,
+ name: transformRef.name,
type: "transform",
- transform,
+ transformRef: transformRef,
};
return {
...state,
openedTabs: [...state.openedTabs, newTransformTab],
activeTab: newTransformTab,
- activeTransform: transform,
+ activeTransformRef: transformRef,
activeTable: null,
};
}
@@ -337,12 +367,12 @@ export const WorkspaceProvider = ({
);
const addOpenedTransform = useCallback(
- (transform: TaggedTransform | WorkspaceTransform | UnsavedTransform) => {
+ (transformRef: AnyWorkspaceTransformRef) => {
const transformTab: TransformTab = {
- id: getTransformTabId(transform),
- name: transform.name,
+ id: getTransformTabId(transformRef),
+ name: transformRef.name,
type: "transform",
- transform,
+ transformRef: transformRef,
};
addOpenedTab(transformTab);
},
@@ -364,7 +394,10 @@ export const WorkspaceProvider = ({
const patchEditedTransform = useCallback(
(transformId: number | string, patch: Partial<EditedTransform>) => {
updateWorkspaceState((state) => {
- const activeTransform = checkNotNull(state.activeTransform);
+ if (!activeTransform) {
+ return state;
+ }
+
const currentTransform =
state.editedTransforms.get(transformId) ?? activeTransform;
const newEditedTransform: EditedTransform = {
@@ -389,7 +422,7 @@ export const WorkspaceProvider = ({
const newOpenedTabs = state.openedTabs.map((tab) => {
if (
tab.type === "transform" &&
- getTransformId(tab.transform) === transformId
+ getTransformId(tab.transformRef) === transformId
) {
return {
...tab,
@@ -406,7 +439,7 @@ export const WorkspaceProvider = ({
};
});
},
- [updateWorkspaceState],
+ [activeTransform, updateWorkspaceState],
);
const removeEditedTransform = useCallback(
@@ -430,11 +463,11 @@ export const WorkspaceProvider = ({
const newOpenedTabs = state.openedTabs.map((tab) => {
if (
tab.type === "transform" &&
- getTransformId(tab.transform) === transformId
+ getTransformId(tab.transformRef) === transformId
) {
return {
...tab,
- transform,
+ transformRef: transform,
name: transform.name,
};
}
@@ -461,17 +494,17 @@ export const WorkspaceProvider = ({
}
}
- const activeTransformId = state.activeTransform
- ? getTransformId(state.activeTransform)
+ const activeTransformId = state.activeTransformRef
+ ? getTransformId(state.activeTransformRef)
: undefined;
return {
...state,
openedTabs: newOpenedTabs,
- activeTransform:
+ activeTransformRef:
activeTransformId === transformId
? transform
- : state.activeTransform,
+ : state.activeTransformRef,
editedTransforms: newEditedTransforms,
};
});
@@ -541,8 +574,8 @@ export const WorkspaceProvider = ({
const currentIndex = state.nextUnsavedTransformIndex;
const name =
currentIndex === 0
- ? "New transform"
- : `New transform (${currentIndex})`;
+ ? t`New transform`
+ : t`New transform (${currentIndex})`;
const newTransform: UnsavedTransform = {
type: "unsaved-transform",
@@ -569,7 +602,7 @@ export const WorkspaceProvider = ({
id: getTransformTabId(newTransform),
name: newTransform.name,
type: "transform",
- transform: newTransform,
+ transformRef: newTransform,
};
return {
@@ -579,7 +612,7 @@ export const WorkspaceProvider = ({
editedTransforms: newEditedTransforms,
openedTabs: [...state.openedTabs, newTransformTab],
activeTab: newTransformTab,
- activeTransform: newTransform,
+ activeTransformRef: newTransform,
activeTable: null,
};
});
@@ -604,11 +637,11 @@ export const WorkspaceProvider = ({
);
// Clear active state if this was the active transform
- const activeTransformId = state.activeTransform
- ? getTransformId(state.activeTransform)
+ const activeTransformId = state.activeTransformRef
+ ? getTransformId(state.activeTransformRef)
: undefined;
- const newActiveTransform =
- activeTransformId === transformId ? null : state.activeTransform;
+ const newActiveTransformRef =
+ activeTransformId === transformId ? null : state.activeTransformRef;
const newActiveTab =
state.activeTab?.id === tabId ? null : state.activeTab;
@@ -617,7 +650,7 @@ export const WorkspaceProvider = ({
unsavedTransforms: newUnsavedTransforms,
editedTransforms: newEditedTransforms,
openedTabs: newOpenedTabs,
- activeTransform: newActiveTransform,
+ activeTransformRef: newActiveTransformRef,
activeTab: newActiveTab,
};
});
@@ -639,7 +672,7 @@ export const WorkspaceProvider = ({
...state,
activeTab: existingTab,
activeTable: table,
- activeTransform: null,
+ activeTransformRef: null,
};
} else {
const newTableTab: TableTab = {
@@ -654,7 +687,7 @@ export const WorkspaceProvider = ({
openedTabs: [...state.openedTabs, newTableTab],
activeTab: newTableTab,
activeTable: table,
- activeTransform: null,
+ activeTransformRef: null,
};
}
} else {
@@ -679,12 +712,12 @@ export const WorkspaceProvider = ({
() => ({
workspaceId,
openedTabs,
- activeTransform,
+ activeTransformRef,
activeTable,
activeTab,
activeEditedTransform,
setActiveTab,
- setActiveTransform,
+ setActiveTransformRef,
setActiveTable,
addOpenedTab,
removeOpenedTab,
@@ -705,12 +738,12 @@ export const WorkspaceProvider = ({
[
workspaceId,
openedTabs,
- activeTransform,
+ activeTransformRef,
activeTable,
activeTab,
activeEditedTransform,
setActiveTab,
- setActiveTransform,
+ setActiveTransformRef,
setActiveTable,
addOpenedTab,
removeOpenedTab,
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useActiveTransform.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useActiveTransform.ts
new file mode 100644
index 00000000000..5d021aed1ee
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useActiveTransform.ts
@@ -0,0 +1,66 @@
+import { useMemo } from "react";
+
+import { skipToken, useGetTransformQuery } from "metabase/api";
+import { useGetWorkspaceTransformQuery } from "metabase-enterprise/api";
+import type {
+ TaggedTransform,
+ UnsavedTransform,
+ WorkspaceId,
+} from "metabase-types/api";
+
+import type { AnyWorkspaceTransformRef } from "./WorkspaceProvider";
+
+export const useActiveTransform = ({
+ transformRef,
+ unsavedTransforms,
+ workspaceId,
+}: {
+ transformRef: AnyWorkspaceTransformRef | null;
+ unsavedTransforms: UnsavedTransform[];
+ workspaceId: WorkspaceId;
+}) => {
+ const transformQuery = useGetTransformQuery(
+ transformRef?.type === "transform" ? transformRef.id : skipToken,
+ );
+
+ const workspaceTransformQuery = useGetWorkspaceTransformQuery(
+ transformRef?.type === "workspace-transform"
+ ? { transformId: transformRef.ref_id, workspaceId }
+ : skipToken,
+ );
+
+ const transform = useMemo(() => {
+ const transform = transformQuery.data;
+ const taggedTransform: TaggedTransform | null = transform
+ ? { ...transform, type: "transform" }
+ : null;
+
+ return {
+ ...transformQuery,
+ data: taggedTransform,
+ };
+ }, [transformQuery]);
+
+ const workspaceTransform = useMemo(() => {
+ return {
+ ...workspaceTransformQuery,
+ data: workspaceTransformQuery.data ?? null,
+ };
+ }, [workspaceTransformQuery]);
+
+ if (transformRef?.type === "transform") {
+ return transform;
+ }
+
+ if (transformRef?.type === "workspace-transform") {
+ return workspaceTransform;
+ }
+
+ return {
+ data: unsavedTransforms.find(
+ (transform) => transform.id === transformRef?.id,
+ ),
+ isLoading: false,
+ error: undefined,
+ };
+};
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceActions.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceActions.ts
index db6af2905e4..c08826e79b6 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceActions.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceActions.ts
@@ -2,20 +2,17 @@ import { useCallback, useState } from "react";
import { replace } from "react-router-redux";
import { t } from "ttag";
-import { useLazyGetTransformQuery } from "metabase/api";
import { useDispatch } from "metabase/lib/redux";
import * as Urls from "metabase/lib/urls";
import { useMetadataToasts } from "metabase/metadata/hooks";
import {
useLazyGetWorkspaceTablesQuery,
- useLazyGetWorkspaceTransformQuery,
useMergeWorkspaceMutation,
useRunWorkspaceTransformMutation,
useUpdateWorkspaceMutation,
} from "metabase-enterprise/api";
import type {
ExternalTransform,
- TaggedTransform,
Workspace,
WorkspaceTransformListItem,
} from "metabase-types/api";
@@ -44,14 +41,12 @@ export function useWorkspaceActions({
const dispatch = useDispatch();
const { sendErrorToast, sendSuccessToast } = useMetadataToasts();
- const { addOpenedTab, addOpenedTransform, setActiveTransform } =
+ const { addOpenedTab, addOpenedTransform, setActiveTransformRef } =
useWorkspace();
const [mergeWorkspace, { isLoading: isMerging }] =
useMergeWorkspaceMutation();
const [updateWorkspace] = useUpdateWorkspaceMutation();
const [runTransform] = useRunWorkspaceTransformMutation();
- const [fetchWorkspaceTransform] = useLazyGetWorkspaceTransformQuery();
- const [fetchTransform] = useLazyGetTransformQuery();
const [runningTransforms, setRunningTransforms] = useState<Set<string>>(
new Set(),
);
@@ -131,8 +126,10 @@ export function useWorkspaceActions({
return;
}
- const { data: updatedTables, error } =
- await getWorkspaceTables(workspaceId);
+ const { data: updatedTables, error } = await getWorkspaceTables(
+ workspaceId,
+ true,
+ );
const updatedOutput = updatedTables?.outputs.find(
(t) => t.isolated.transform_id === transform.ref_id,
);
@@ -168,20 +165,13 @@ export function useWorkspaceActions({
const handleTransformClick = useCallback(
async (workspaceTransform: WorkspaceTransformListItem) => {
- const { data: transform, error } = await fetchWorkspaceTransform(
- {
- workspaceId,
- transformId: workspaceTransform.ref_id,
- },
- true,
- );
- if (error) {
- sendErrorToast(t`Failed to fetch transform`);
- } else if (transform) {
- addOpenedTransform(transform);
- }
+ addOpenedTransform({
+ type: "workspace-transform",
+ ref_id: workspaceTransform.ref_id,
+ name: workspaceTransform.name,
+ });
},
- [workspaceId, fetchWorkspaceTransform, addOpenedTransform, sendErrorToast],
+ [addOpenedTransform],
);
// Callback to navigate to a transform (used by metabot reactions and URL param)
@@ -202,31 +192,29 @@ export function useWorkspaceActions({
const isWsTransform = !!transform && "global_id" in transform;
if (transform && !isWsTransform) {
- const { data, error } = await fetchTransform(transform.id, true);
-
- if (error) {
- sendErrorToast(t`Failed to fetch transform`);
- } else if (data) {
- const taggedTransform: TaggedTransform = {
- ...data,
- type: "transform",
- };
- addOpenedTransform(taggedTransform);
- setActiveTransform(taggedTransform);
- onOpenTab(String(targetTransformId));
- }
+ addOpenedTransform({
+ type: "transform",
+ id: transform.id,
+ name: transform.name,
+ });
+ setActiveTransformRef({
+ type: "transform",
+ id: transform.id,
+ name: transform.name,
+ });
+ onOpenTab(String(targetTransformId));
} else if (transform && isWsTransform) {
- const { data, error } = await fetchWorkspaceTransform({
- workspaceId,
- transformId: transform.ref_id,
+ addOpenedTransform({
+ type: "workspace-transform",
+ ref_id: transform.ref_id,
+ name: transform.name,
});
- if (error) {
- sendErrorToast(t`Failed to fetch transform`);
- } else if (data) {
- addOpenedTransform(data);
- setActiveTransform(data);
- onOpenTab(String(targetTransformId));
- }
+ setActiveTransformRef({
+ type: "workspace-transform",
+ ref_id: transform.ref_id,
+ name: transform.name,
+ });
+ onOpenTab(String(targetTransformId));
} else {
sendErrorToast(`Transform ${targetTransformId} not found`);
}
@@ -234,11 +222,8 @@ export function useWorkspaceActions({
[
workspaceTransforms,
availableTransforms,
- workspaceId,
- fetchTransform,
- fetchWorkspaceTransform,
addOpenedTransform,
- setActiveTransform,
+ setActiveTransformRef,
onOpenTab,
sendErrorToast,
],
diff --git a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceMetabot.ts b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceMetabot.ts
index c1a47d05d71..1a18da06dcb 100644
--- a/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceMetabot.ts
+++ b/enterprise/frontend/src/metabase-enterprise/data-studio/workspaces/pages/WorkspacePage/useWorkspaceMetabot.ts
@@ -92,7 +92,7 @@ export function useWorkspaceMetabot({
openedTabs,
setActiveTab,
addOpenedTransform,
- setActiveTransform,
+ setActiveTransformRef,
addUnsavedTransform,
unsavedTransforms,
patchEditedTransform,
@@ -128,10 +128,10 @@ export function useWorkspaceMetabot({
type: "transform",
};
addOpenedTransform(taggedTransform);
- setActiveTransform(taggedTransform);
+ setActiveTransformRef(taggedTransform);
setTab(getTransformTabId(taggedTransform));
},
- [addOpenedTransform, setActiveTransform, setTab],
+ [addOpenedTransform, setActiveTransformRef, setTab],
);
const applySuggestion = useCallback(
@@ -246,9 +246,9 @@ export function useWorkspaceMetabot({
const openTransform = useCallback(
(nextTransform: { type: "transform" } & Transform) => {
addOpenedTransform(nextTransform);
- setActiveTransform(nextTransform);
+ setActiveTransformRef(nextTransform);
},
- [addOpenedTransform, setActiveTransform],
+ [addOpenedTransform, setActiveTransformRef],
);
const suggestionActions = useMemo<MetabotSuggestionActions>(
@@ -287,7 +287,7 @@ export function useWorkspaceMetabot({
!openedTabs.some(
(tab) =>
tab.type === "transform" &&
- getTransformId(tab.transform) ===
+ getTransformId(tab.transformRef) ===
getTransformId(metabotContextTransform),
)
) {
@@ -369,7 +369,7 @@ export function useWorkspaceMetabot({
const existingTab = openedTabs.find(
(tab) =>
tab.type === "transform" &&
- getTransformId(tab.transform) === localTransform.id,
+ getTransformId(tab.transformRef) === localTransform.id,
);
if (existingTab) {
setActiveTab(existingTab);
diff --git a/frontend/src/metabase-types/api/workspace.ts b/frontend/src/metabase-types/api/workspace.ts
index 1eb213a524f..504a2acdfde 100644
--- a/frontend/src/metabase-types/api/workspace.ts
+++ b/frontend/src/metabase-types/api/workspace.ts
@@ -1,6 +1,7 @@
import type { CollectionId } from "./collection";
import type { DatabaseId } from "./database";
import type { DatasetColumn, ResultsMetadata, RowValues } from "./dataset";
+import type { SchemaName } from "./table";
import type {
DraftTransformSource,
Transform,
@@ -23,7 +24,7 @@ export type TaggedTransform = Transform & { type: "transform" };
*/
export type UnsavedTransform = {
type: "unsaved-transform";
- id: number;
+ id: TransformId;
name: string;
source: DraftTransformSource;
target: {
@@ -529,7 +530,7 @@ export type WorkspaceTransformRunResponse = {
message?: string | null;
table: {
name: string;
- schema?: string | null;
+ schema?: SchemaName | null;
};
};