Skip to content

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

Fetch every plugin route factory when its route is matched (#79637)

Romeo Van Snick2d2e90cf66e4
diff --git a/enterprise/frontend/src/metabase-enterprise/ai-controls/routes.tsx b/enterprise/frontend/src/metabase-enterprise/ai-controls/routes.tsx
index cc46d048768..77b43a54712 100644
--- a/enterprise/frontend/src/metabase-enterprise/ai-controls/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/ai-controls/routes.tsx
@@ -1,54 +1,157 @@
-import { Route } from "metabase/router";
+import { Route, registerPagePrefetch } from "metabase/router";
+import * as Urls from "metabase/urls";
import { RequireMetabotConfigured } from "./components/RequireMetabotConfigured";
-import {
- MetabotCustomizationPage,
- MetabotCustomizationUpsellPage,
-} from "./pages/MetabotCustomizationPage";
-import {
- MetabotFeatureAccessPage,
- MetabotFeatureAccessUpsellPage,
-} from "./pages/MetabotFeatureAccessPage";
-import {
- MetabotChatPromptPage,
- MetabotSystemPromptsUpsellPage,
- NaturalLanguagePromptPage,
- SqlGenerationPromptPage,
-} from "./pages/MetabotSystemPromptsPage";
-import { MetabotUsageLimitsPage } from "./pages/MetabotUsageLimitsPage";
+
+/**
+ * The AI settings pages, each in its own chunk.
+ *
+ * The nine loaders below resolve to four page modules, and those four share
+ * under a tenth of their weight, so one chunk for the section would make a
+ * visit to any single tab pay for all of them.
+ *
+ * `RequireMetabotConfigured` is not split. It redirects away when Metabot is
+ * unconfigured, so splitting it would put a fetch in front of a redirect that
+ * renders nothing.
+ */
+const metabotFeatureAccessPage = () =>
+ import("./pages/MetabotFeatureAccessPage").then(
+ ({ MetabotFeatureAccessPage }) => ({
+ Component: MetabotFeatureAccessPage,
+ }),
+ );
+
+const metabotFeatureAccessUpsellPage = () =>
+ import("./pages/MetabotFeatureAccessPage").then(
+ ({ MetabotFeatureAccessUpsellPage }) => ({
+ Component: MetabotFeatureAccessUpsellPage,
+ }),
+ );
+
+const metabotUsageLimitsPage = () =>
+ import("./pages/MetabotUsageLimitsPage").then(
+ ({ MetabotUsageLimitsPage }) => ({
+ Component: MetabotUsageLimitsPage,
+ }),
+ );
+
+const metabotCustomizationPage = () =>
+ import("./pages/MetabotCustomizationPage").then(
+ ({ MetabotCustomizationPage }) => ({
+ Component: MetabotCustomizationPage,
+ }),
+ );
+
+const metabotCustomizationUpsellPage = () =>
+ import("./pages/MetabotCustomizationPage").then(
+ ({ MetabotCustomizationUpsellPage }) => ({
+ Component: MetabotCustomizationUpsellPage,
+ }),
+ );
+
+const metabotChatPromptPage = () =>
+ import("./pages/MetabotSystemPromptsPage").then(
+ ({ MetabotChatPromptPage }) => ({ Component: MetabotChatPromptPage }),
+ );
+
+const naturalLanguagePromptPage = () =>
+ import("./pages/MetabotSystemPromptsPage").then(
+ ({ NaturalLanguagePromptPage }) => ({
+ Component: NaturalLanguagePromptPage,
+ }),
+ );
+
+const sqlGenerationPromptPage = () =>
+ import("./pages/MetabotSystemPromptsPage").then(
+ ({ SqlGenerationPromptPage }) => ({
+ Component: SqlGenerationPromptPage,
+ }),
+ );
+
+const metabotSystemPromptsUpsellPage = () =>
+ import("./pages/MetabotSystemPromptsPage").then(
+ ({ MetabotSystemPromptsUpsellPage }) => ({
+ Component: MetabotSystemPromptsUpsellPage,
+ }),
+ );
+
+/**
+ * One spelling of each path, used by the routes below and by the prefetch
+ * registrations. The registry matches a hovered link against a literal prefix,
+ * so a segment renamed in only one of the two places would stop prefetching
+ * without failing anything.
+ */
+const PATHS = {
+ featureAccess: "usage-controls/ai-feature-access",
+ usageLimits: "usage-controls/ai-usage-limits",
+ customization: "customization",
+ systemPrompts: "system-prompts",
+ chatPrompt: "system-prompts/metabot-chat",
+ naturalLanguagePrompt: "system-prompts/natural-language-queries",
+ sqlGenerationPrompt: "system-prompts/sql-generation",
+} as const;
+
+const adminAiPath = (path: string) => `${Urls.adminAiSettings()}/${path}`;
+
+/**
+ * Hovering an AI settings tab starts its fetch, so the chunk is usually in hand
+ * by the time the click lands.
+ *
+ * The pages that differ only by license come from one module, so a registration
+ * covers both. The three system prompt tabs are one module too, which is why the
+ * prefix they share is registered once.
+ */
+registerPagePrefetch(
+ adminAiPath(PATHS.featureAccess),
+ metabotFeatureAccessPage,
+);
+registerPagePrefetch(
+ adminAiPath(PATHS.featureAccess),
+ metabotFeatureAccessUpsellPage,
+);
+registerPagePrefetch(adminAiPath(PATHS.usageLimits), metabotUsageLimitsPage);
+registerPagePrefetch(
+ adminAiPath(PATHS.customization),
+ metabotCustomizationPage,
+);
+registerPagePrefetch(
+ adminAiPath(PATHS.customization),
+ metabotCustomizationUpsellPage,
+);
+registerPagePrefetch(adminAiPath(PATHS.systemPrompts), metabotChatPromptPage);
export function getAiControlsRoutes() {
return (
<Route element={<RequireMetabotConfigured />}>
<Route
key="ai-feature-access"
- path="usage-controls/ai-feature-access"
- element={<MetabotFeatureAccessPage />}
+ path={PATHS.featureAccess}
+ lazy={metabotFeatureAccessPage}
/>
<Route
key="ai-usage-limits"
- path="usage-controls/ai-usage-limits"
- element={<MetabotUsageLimitsPage />}
+ path={PATHS.usageLimits}
+ lazy={metabotUsageLimitsPage}
/>
<Route
key="customization"
- path="customization"
- element={<MetabotCustomizationPage />}
+ path={PATHS.customization}
+ lazy={metabotCustomizationPage}
/>
<Route
key="system-prompts-metabot-chat"
- path="system-prompts/metabot-chat"
- element={<MetabotChatPromptPage />}
+ path={PATHS.chatPrompt}
+ lazy={metabotChatPromptPage}
/>
<Route
key="system-prompts-natural-language-queries"
- path="system-prompts/natural-language-queries"
- element={<NaturalLanguagePromptPage />}
+ path={PATHS.naturalLanguagePrompt}
+ lazy={naturalLanguagePromptPage}
/>
<Route
key="system-prompts-sql-generation"
- path="system-prompts/sql-generation"
- element={<SqlGenerationPromptPage />}
+ path={PATHS.sqlGenerationPrompt}
+ lazy={sqlGenerationPromptPage}
/>
</Route>
);
@@ -59,18 +162,18 @@ export function getAiControlsUpsellRoutes() {
<>
<Route
key="ai-feature-access"
- path="usage-controls/ai-feature-access"
- element={<MetabotFeatureAccessUpsellPage />}
+ path={PATHS.featureAccess}
+ lazy={metabotFeatureAccessUpsellPage}
/>
<Route
key="customization"
- path="customization"
- element={<MetabotCustomizationUpsellPage />}
+ path={PATHS.customization}
+ lazy={metabotCustomizationUpsellPage}
/>
<Route
key="system-prompts"
- path="system-prompts/metabot-chat"
- element={<MetabotSystemPromptsUpsellPage />}
+ path={PATHS.chatPrompt}
+ lazy={metabotSystemPromptsUpsellPage}
/>
</>
);
diff --git a/enterprise/frontend/src/metabase-enterprise/application_permissions/routes.tsx b/enterprise/frontend/src/metabase-enterprise/application_permissions/routes.tsx
index f467eb6a19e..0e40f8d19bc 100644
--- a/enterprise/frontend/src/metabase-enterprise/application_permissions/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/application_permissions/routes.tsx
@@ -1,9 +1,16 @@
-import { Route } from "metabase/router";
+import { Route, registerPagePrefetch } from "metabase/router";
-import ApplicationPermissionsPage from "./pages/ApplicationPermissionsPage";
+const APPLICATION_PERMISSIONS_PATH = "/admin/permissions/application";
+
+const applicationPermissionsPage = () =>
+ import("./pages/ApplicationPermissionsPage").then((module) => ({
+ Component: module.default,
+ }));
+
+registerPagePrefetch(APPLICATION_PERMISSIONS_PATH, applicationPermissionsPage);
const getRoutes = () => (
- <Route path="application" element={<ApplicationPermissionsPage />} />
+ <Route path="application" lazy={applicationPermissionsPage} />
);
// eslint-disable-next-line import/no-default-export -- deprecated usage
diff --git a/enterprise/frontend/src/metabase-enterprise/data_apps/routes.tsx b/enterprise/frontend/src/metabase-enterprise/data_apps/routes.tsx
index 0b70af37a46..58e77e593c4 100644
--- a/enterprise/frontend/src/metabase-enterprise/data_apps/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/data_apps/routes.tsx
@@ -1,8 +1,26 @@
-import { Outlet, Route } from "metabase/router";
+import { Outlet, Route, registerPagePrefetch } from "metabase/router";
import * as Urls from "metabase/urls";
-import { DataAppLayout } from "./components/DataAppLayout/DataAppLayout";
-import { DataAppView } from "./components/DataAppView/DataAppView";
+const dataAppLayout = () =>
+ import("./components/DataAppLayout/DataAppLayout").then(
+ ({ DataAppLayout }) => ({
+ Component: function DataAppLayoutRoute() {
+ return (
+ <DataAppLayout>
+ <Outlet />
+ </DataAppLayout>
+ );
+ },
+ }),
+ );
+
+const dataAppView = () =>
+ import("./components/DataAppView/DataAppView").then(({ DataAppView }) => ({
+ Component: DataAppView,
+ }));
+
+registerPagePrefetch(`${Urls.DATA_APP_ROOT_URL}/`, dataAppLayout);
+registerPagePrefetch(`${Urls.DATA_APP_ROOT_URL}/`, dataAppView);
/**
* Data-app host routes. Open to any signed-in user.
@@ -12,20 +30,13 @@ import { DataAppView } from "./components/DataAppView/DataAppView";
*/
export function getRoutes() {
return (
- <Route
- path={`${Urls.DATA_APP_URL_SEGMENT}/:name`}
- element={
- <DataAppLayout>
- <Outlet />
- </DataAppLayout>
- }
- >
- <Route index element={<DataAppView />} />
+ <Route path={`${Urls.DATA_APP_URL_SEGMENT}/:name`} lazy={dataAppLayout}>
+ <Route index lazy={dataAppView} />
{/* Sub-paths under /apps/:name are owned by the iframe's router.
Same component — `DataAppView` just keeps the iframe mounted; the URL
change is mirrored back from inside the iframe via
`history.replaceState`. */}
- <Route path="*" element={<DataAppView />} />
+ <Route path="*" lazy={dataAppView} />
</Route>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/dependencies/routes.tsx b/enterprise/frontend/src/metabase-enterprise/dependencies/routes.tsx
index 4e2f43ab1d8..04845414603 100644
--- a/enterprise/frontend/src/metabase-enterprise/dependencies/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/dependencies/routes.tsx
@@ -1,7 +1,10 @@
import { Route } from "metabase/router";
-import { DependencyGraphPage } from "./pages/DependencyGraphPage";
+const dependencyGraphPage = () =>
+ import("./pages/DependencyGraphPage").then(({ DependencyGraphPage }) => ({
+ Component: DependencyGraphPage,
+ }));
export function getDataStudioDependencyRoutes() {
- return <Route index element={<DependencyGraphPage />} />;
+ return <Route index lazy={dependencyGraphPage} />;
}
diff --git a/enterprise/frontend/src/metabase-enterprise/lazy-plugin-routes.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/lazy-plugin-routes.unit.spec.tsx
new file mode 100644
index 00000000000..72c40575c7c
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/lazy-plugin-routes.unit.spec.tsx
@@ -0,0 +1,68 @@
+import type { ReactNode } from "react";
+
+import { type RouteObject, toRouteObjects } from "metabase/router";
+import {
+ getAiControlsRoutes,
+ getAiControlsUpsellRoutes,
+} from "metabase-enterprise/ai-controls/routes";
+import getApplicationPermissionsRoutes from "metabase-enterprise/application_permissions/routes";
+import { getRoutes as getDataAppRoutes } from "metabase-enterprise/data_apps/routes";
+import { getDataStudioDependencyRoutes } from "metabase-enterprise/dependencies/routes";
+import { getTransformToolsRoutes } from "metabase-enterprise/replacement/routes";
+import { getDataStudioSchemaViewerRoutes } from "metabase-enterprise/schema_viewer/routes";
+import { getRoutes as getTableEditingRoutes } from "metabase-enterprise/table-editing/routes";
+import {
+ getInspectorRoutes,
+ getInspectorUpsellRoutes,
+} from "metabase-enterprise/transforms-inspector/routes";
+import { getPythonTransformsRoutes } from "metabase-enterprise/transforms-python/routes";
+
+/**
+ * A plugin route factory names its page in an `import()` rather than importing
+ * it, so nothing type-checks the path or the export any more. Nothing renders
+ * these route trees in a test either, so a typo would first show up as a blank
+ * admin page. Resolving every loader is the cheap guard against that.
+ */
+function lazyLoaders(tree: ReactNode) {
+ const loaders: (() => Promise<{ Component?: unknown }>)[] = [];
+
+ const collect = (routes: RouteObject[]) => {
+ for (const route of routes) {
+ if (typeof route.lazy === "function") {
+ loaders.push(route.lazy);
+ }
+ collect(route.children ?? []);
+ }
+ };
+
+ collect(toRouteObjects(tree));
+ return loaders;
+}
+
+const FACTORIES: [string, ReactNode, number][] = [
+ ["ai-controls", getAiControlsRoutes(), 6],
+ ["ai-controls upsell", getAiControlsUpsellRoutes(), 3],
+ ["schema viewer", getDataStudioSchemaViewerRoutes(), 1],
+ ["transforms inspector", getInspectorRoutes(), 2],
+ ["transforms inspector upsell", getInspectorUpsellRoutes(), 2],
+ ["application permissions", getApplicationPermissionsRoutes(), 1],
+ ["table editing", getTableEditingRoutes(), 1],
+ ["python transforms", getPythonTransformsRoutes(), 2],
+ ["model replacement", getTransformToolsRoutes(), 1],
+ ["data studio dependencies", getDataStudioDependencyRoutes(), 1],
+ ["data apps", getDataAppRoutes(), 3],
+];
+
+describe("lazy plugin routes", () => {
+ it.each(FACTORIES)(
+ "resolves every page in %s",
+ async (_name, tree, count) => {
+ const loaders = lazyLoaders(tree);
+ expect(loaders).toHaveLength(count);
+
+ for (const load of loaders) {
+ expect((await load()).Component).toBeDefined();
+ }
+ },
+ );
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/replacement/routes.tsx b/enterprise/frontend/src/metabase-enterprise/replacement/routes.tsx
index 6cb1ae1734a..584e667aca7 100644
--- a/enterprise/frontend/src/metabase-enterprise/replacement/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/replacement/routes.tsx
@@ -1,11 +1,17 @@
-import { Route } from "metabase/router";
+import { Route, registerPagePrefetch } from "metabase/router";
+import * as Urls from "metabase/urls";
-import { MigrateModelsPage } from "./pages/MigrateModelsPage";
+const migrateModelsPage = () =>
+ import("./pages/MigrateModelsPage").then(({ MigrateModelsPage }) => ({
+ Component: MigrateModelsPage,
+ }));
+
+registerPagePrefetch(Urls.transformMigrateModels(), migrateModelsPage);
export function getTransformToolsRoutes() {
return (
<Route path="tools">
- <Route path="migrate-models" element={<MigrateModelsPage />} />
+ <Route path="migrate-models" lazy={migrateModelsPage} />
</Route>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/schema_viewer/routes.tsx b/enterprise/frontend/src/metabase-enterprise/schema_viewer/routes.tsx
index c01d004c74e..3b4a83b26cd 100644
--- a/enterprise/frontend/src/metabase-enterprise/schema_viewer/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/schema_viewer/routes.tsx
@@ -1,7 +1,13 @@
-import { Route } from "metabase/router";
+import { Route, registerPagePrefetch } from "metabase/router";
+import * as Urls from "metabase/urls";
-import { SchemaViewerPage } from "./pages/SchemaViewerPage";
+const schemaViewerPage = () =>
+ import("./pages/SchemaViewerPage").then(({ SchemaViewerPage }) => ({
+ Component: SchemaViewerPage,
+ }));
+
+registerPagePrefetch(Urls.dataStudioSchemaViewer(), schemaViewerPage);
export function getDataStudioSchemaViewerRoutes() {
- return <Route index element={<SchemaViewerPage />} />;
+ return <Route index lazy={schemaViewerPage} />;
}
diff --git a/enterprise/frontend/src/metabase-enterprise/table-editing/routes.tsx b/enterprise/frontend/src/metabase-enterprise/table-editing/routes.tsx
index 0a3e64578d6..8679f901a81 100644
--- a/enterprise/frontend/src/metabase-enterprise/table-editing/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/table-editing/routes.tsx
@@ -1,12 +1,25 @@
import { Route } from "metabase/router";
-import { EditTableDataContainer } from "./table-edit/EditTableDataContainer";
+/**
+ * This page registers no prefetch, unlike the other pages that were split.
+ *
+ * `registerPagePrefetch` takes a fixed path prefix and matches it against the
+ * start of a hovered link's target. What names this page is the `edit` segment,
+ * and it comes after two ids that differ per table, so no fixed prefix reaches
+ * it. The longest one available stops at `databases`, which every browse
+ * database link also starts with. Registering that would fetch this chunk on
+ * hover of links that do not lead here.
+ */
+const editTableDataPage = () =>
+ import("./table-edit/EditTableDataContainer").then(
+ ({ EditTableDataContainer }) => ({ Component: EditTableDataContainer }),
+ );
export function getRoutes() {
return (
<Route
path="databases/:dbId/tables/:tableId/edit/:objectId?"
- element={<EditTableDataContainer />}
+ lazy={editTableDataPage}
/>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/transforms-inspector/routes.tsx b/enterprise/frontend/src/metabase-enterprise/transforms-inspector/routes.tsx
index febf71ee526..962c743560f 100644
--- a/enterprise/frontend/src/metabase-enterprise/transforms-inspector/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/transforms-inspector/routes.tsx
@@ -1,18 +1,34 @@
import { Route } from "metabase/router";
-import { TransformInspectorUpsellPage } from "metabase-enterprise/transforms-python/upsells/PythonTransformsUpsellModal/TransformInspectorUpsellPage";
-import { TransformInspectPage } from "./pages/TransformInspectPage";
+/**
+ * These pages register no prefetch, unlike the other pages that were split.
+ *
+ * `registerPagePrefetch` takes a fixed path prefix and matches it against the
+ * start of a hovered link's target. What names these pages is the `inspect`
+ * segment, and it comes after the transform id, so no fixed prefix reaches them.
+ * The longest one available stops before the id, which every other transform
+ * page also starts with. Registering that would fetch this chunk on hover of
+ * links that do not lead here.
+ */
+const transformInspectPage = () =>
+ import("./pages/TransformInspectPage").then(({ TransformInspectPage }) => ({
+ Component: TransformInspectPage,
+ }));
+
+const transformInspectorUpsellPage = () =>
+ import("metabase-enterprise/transforms-python/upsells/PythonTransformsUpsellModal/TransformInspectorUpsellPage").then(
+ ({ TransformInspectorUpsellPage }) => ({
+ Component: TransformInspectorUpsellPage,
+ }),
+ );
export function getInspectorUpsellRoutes() {
return (
<>
- <Route
- path=":transformId/inspect"
- element={<TransformInspectorUpsellPage />}
- />
+ <Route path=":transformId/inspect" lazy={transformInspectorUpsellPage} />
<Route
path=":transformId/inspect/:lensId"
- element={<TransformInspectorUpsellPage />}
+ lazy={transformInspectorUpsellPage}
/>
</>
);
@@ -21,11 +37,8 @@ export function getInspectorUpsellRoutes() {
export function getInspectorRoutes() {
return (
<>
- <Route path=":transformId/inspect" element={<TransformInspectPage />} />
- <Route
- path=":transformId/inspect/:lensId"
- element={<TransformInspectPage />}
- />
+ <Route path=":transformId/inspect" lazy={transformInspectPage} />
+ <Route path=":transformId/inspect/:lensId" lazy={transformInspectPage} />
</>
);
}