Skip to content

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

Remove Segment entity (#74064)

Romeo Van Snick30033828b892
diff --git a/frontend/src/metabase-lib/v1/metadata/Metadata.ts b/frontend/src/metabase-lib/v1/metadata/Metadata.ts
index 898f040da69..b5578a40f48 100644
--- a/frontend/src/metabase-lib/v1/metadata/Metadata.ts
+++ b/frontend/src/metabase-lib/v1/metadata/Metadata.ts
@@ -10,7 +10,7 @@ import type {
Metric,
NativeQuerySnippet,
SchemaId,
- SegmentId,
+ Segment,
SettingKey,
Settings,
TableId,
@@ -22,7 +22,6 @@ import type Database from "./Database";
import type Field from "./Field";
import type Measure from "./Measure";
import type Schema from "./Schema";
-import type Segment from "./Segment";
import type Table from "./Table";
import { getUniqueFieldId } from "./utils/fields";
import { SAVED_QUESTIONS_VIRTUAL_DB_ID } from "./utils/saved-questions";
@@ -89,20 +88,6 @@ class Metadata {
return Object.values(this.fields);
}
- /**
- * @deprecated load data via RTK Query - useListSegmentsQuery
- */
- segmentsList(): Segment[] {
- return Object.values(this.segments);
- }
-
- /**
- * @deprecated load data via RTK Query - useGetSegmentQuery
- */
- segment(segmentId: SegmentId | undefined | null): Segment | null {
- return (segmentId != null && this.segments[segmentId]) || null;
- }
-
/**
* @deprecated load data via RTK Query - useListMeasuresQuery
*/
diff --git a/frontend/src/metabase-lib/v1/metadata/Metadata.unit.spec.ts b/frontend/src/metabase-lib/v1/metadata/Metadata.unit.spec.ts
index 9a391aa151d..cb5923d20fa 100644
--- a/frontend/src/metabase-lib/v1/metadata/Metadata.unit.spec.ts
+++ b/frontend/src/metabase-lib/v1/metadata/Metadata.unit.spec.ts
@@ -2,7 +2,6 @@ import { createMockMetadata } from "__support__/metadata";
import {
createMockDatabase,
createMockField,
- createMockSegment,
createMockTable,
} from "metabase-types/api/mocks";
@@ -68,17 +67,6 @@ describe("Metadata", () => {
});
});
- describe("segmentsList (deprecated)", () => {
- it("should return a list of segment objects found on the instance", () => {
- const metadata = createMockMetadata({
- segments: [createMockSegment({ id: 1 }), createMockSegment({ id: 2 })],
- });
-
- const segments = metadata.segmentsList();
- expect(segments).toEqual([metadata.segment(1), metadata.segment(2)]);
- });
- });
-
describe("`field`", () => {
it("should return null when given a nil fieldId arg", () => {
const metadata = createMockMetadata({});
diff --git a/frontend/src/metabase-lib/v1/metadata/Segment.ts b/frontend/src/metabase-lib/v1/metadata/Segment.ts
deleted file mode 100644
index d85e45d1857..00000000000
--- a/frontend/src/metabase-lib/v1/metadata/Segment.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { Filter, NormalizedSegment } from "metabase-types/api";
-
-import type Metadata from "./Metadata";
-import type Table from "./Table";
-
-interface Segment extends Omit<NormalizedSegment, "table"> {
- table?: Table;
- metadata?: Metadata;
-}
-
-/**
- * @deprecated use RTK Query endpoints and plain api objects from metabase-types/api
- */
-class Segment {
- private readonly _plainObject: NormalizedSegment;
-
- constructor(segment: NormalizedSegment) {
- this._plainObject = segment;
- Object.assign(this, segment);
- }
-
- getPlainObject() {
- return this._plainObject;
- }
-
- displayName() {
- return this.name;
- }
-
- filterClause(): Filter {
- return ["segment", this.id];
- }
-
- isActive() {
- return !this.archived;
- }
-}
-
-// eslint-disable-next-line import/no-default-export -- deprecated usage
-export default Segment;
diff --git a/frontend/src/metabase-lib/v1/metadata/Segment.unit.spec.ts b/frontend/src/metabase-lib/v1/metadata/Segment.unit.spec.ts
deleted file mode 100644
index 38c3b246546..00000000000
--- a/frontend/src/metabase-lib/v1/metadata/Segment.unit.spec.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-import { createMockMetadata } from "__support__/metadata";
-import type { Segment } from "metabase-types/api";
-import { createMockSegment } from "metabase-types/api/mocks";
-
-interface SetupOpts {
- segment?: Segment;
-}
-
-const setup = ({ segment = createMockSegment() }: SetupOpts = {}) => {
- const metadata = createMockMetadata({
- segments: [segment],
- });
-
- const instance = metadata.segment(segment.id);
- if (!instance) {
- throw new TypeError();
- }
-
- return instance;
-};
-
-describe("Segment", () => {
- describe("instantiation", () => {
- it("should create an instance of Segment", () => {
- const segment = setup();
- expect(segment).toBeDefined();
- });
- });
-
- describe("displayName", () => {
- it("should return the `name` property found on the instance", () => {
- const segment = setup({
- segment: createMockSegment({
- name: "foo",
- }),
- });
-
- expect(segment.displayName()).toBe("foo");
- });
- });
-
- describe("filterClause", () => {
- it("should return a filter clause", () => {
- const segment = setup({
- segment: createMockSegment({
- id: 123,
- }),
- });
-
- expect(segment.filterClause()).toEqual(["segment", 123]);
- });
- });
-
- describe("isActive", () => {
- it("should return true if the segment is not archived", () => {
- const segment = setup({
- segment: createMockSegment({
- archived: false,
- }),
- });
-
- expect(segment.isActive()).toBe(true);
- });
-
- it("should return false if the segment is archived", () => {
- const segment = setup({
- segment: createMockSegment({
- archived: true,
- }),
- });
-
- expect(segment.isActive()).toBe(false);
- });
- });
-});
diff --git a/frontend/src/metabase-lib/v1/metadata/Table.ts b/frontend/src/metabase-lib/v1/metadata/Table.ts
index 62a84180a5b..b02353a9fb1 100644
--- a/frontend/src/metabase-lib/v1/metadata/Table.ts
+++ b/frontend/src/metabase-lib/v1/metadata/Table.ts
@@ -2,7 +2,7 @@ import _ from "underscore";
// NOTE: this needs to be imported first due to some cyclical dependency nonsense
import { singularize } from "metabase/utils/formatting";
-import type { NormalizedTable } from "metabase-types/api";
+import type { NormalizedTable, Segment } from "metabase-types/api";
import Question from "../Question";
@@ -12,7 +12,6 @@ import type ForeignKey from "./ForeignKey";
import type Measure from "./Measure";
import type Metadata from "./Metadata";
import type Schema from "./Schema";
-import type Segment from "./Segment";
interface Table extends Omit<
NormalizedTable,
diff --git a/frontend/src/metabase/admin/datamodel/containers/RevisionHistoryApp.tsx b/frontend/src/metabase/admin/datamodel/containers/RevisionHistoryApp.tsx
index 51b7df620bc..49d38bdcdca 100644
--- a/frontend/src/metabase/admin/datamodel/containers/RevisionHistoryApp.tsx
+++ b/frontend/src/metabase/admin/datamodel/containers/RevisionHistoryApp.tsx
@@ -1,96 +1,53 @@
import { useEffect } from "react";
-import _ from "underscore";
-import { Segments } from "metabase/entities/segments";
-import { Tables } from "metabase/entities/tables";
-import { connect } from "metabase/redux";
+import { useGetSegmentQuery } from "metabase/api";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { useLoadTableWithMetadata } from "metabase/data-studio/common/hooks/use-load-table-with-metadata";
+import { useDispatch, useSelector } from "metabase/redux";
import type { State } from "metabase/redux/store";
import { getUser } from "metabase/selectors/user";
import { checkNotNull } from "metabase/utils/types";
-import type { Revision, RevisionId, Segment, User } from "metabase-types/api";
import { RevisionHistory } from "../components/revisions/RevisionHistory";
import { fetchSegmentRevisions } from "../datamodel";
import { getRevisions } from "../selectors";
-type RevisionHistoryAppOwnProps = {
+type RevisionHistoryAppProps = {
params: {
id: string;
};
};
-type RevisionHistoryAppStateProps = {
- id: string;
- revisions: Revision[] | null;
- user: User;
-};
+export function RevisionHistoryApp({ params }: RevisionHistoryAppProps) {
+ const { id } = params;
+ const dispatch = useDispatch();
+ const user = checkNotNull(useSelector(getUser));
+ const revisions = useSelector((state: State) => getRevisions(state));
+ const segmentId = parseInt(id, 10);
-type RevisionHistoryAppDispatchProps = {
- fetchSegmentRevisions: (id: RevisionId | string) => void;
-};
+ const {
+ data: segment,
+ isLoading: isLoadingSegment,
+ error: segmentError,
+ } = useGetSegmentQuery(segmentId);
-type RevisionHistoryAppInnerProps = RevisionHistoryAppOwnProps &
- RevisionHistoryAppStateProps &
- RevisionHistoryAppDispatchProps;
+ const { isLoading: isLoadingTable, error: tableError } =
+ useLoadTableWithMetadata(segment?.table_id, {
+ includeForeignTables: true,
+ });
-const mapStateToProps = (
- state: State,
- props: RevisionHistoryAppOwnProps,
-): RevisionHistoryAppStateProps => ({
- id: props.params.id,
- revisions: getRevisions(state),
- user: checkNotNull(getUser(state)),
-});
+ useEffect(() => {
+ dispatch(fetchSegmentRevisions(id));
+ }, [dispatch, id]);
-const mapDispatchToProps: RevisionHistoryAppDispatchProps = {
- fetchSegmentRevisions,
-};
+ const isLoading = isLoadingSegment || isLoadingTable;
+ const error = segmentError ?? tableError;
-function RevisionHistoryAppInner({
- id,
- user,
- revisions,
- fetchSegmentRevisions,
- ...props
-}: RevisionHistoryAppInnerProps) {
- useEffect(() => {
- fetchSegmentRevisions(id);
- }, [id, fetchSegmentRevisions]);
+ if (isLoading || error || !segment) {
+ return <LoadingAndErrorWrapper loading={isLoading} error={error} />;
+ }
return (
- <SegmentRevisionHistory
- {...props}
- id={id}
- user={user}
- revisions={revisions}
- fetchSegmentRevisions={fetchSegmentRevisions}
- />
+ <RevisionHistory revisions={revisions} segment={segment} user={user} />
);
}
-
-export const RevisionHistoryApp = connect(
- mapStateToProps,
- mapDispatchToProps,
-)(RevisionHistoryAppInner);
-
-type SegmentRevisionHistoryInnerProps = RevisionHistoryAppStateProps &
- RevisionHistoryAppDispatchProps & {
- segment: Segment;
- };
-
-function SegmentRevisionHistoryInner({
- segment,
- ...props
-}: SegmentRevisionHistoryInnerProps) {
- return <RevisionHistory segment={segment} {...props} />;
-}
-
-const SegmentRevisionHistory = _.compose(
- Segments.load({ id: (_state: State, { id }: { id: string }) => id }),
- Tables.load({
- id: (_state: State, { segment }: { segment?: Segment }) =>
- segment?.table_id,
- fetchType: "fetchMetadataAndForeignTables",
- requestType: "fetchMetadataDeprecated",
- }),
-)(SegmentRevisionHistoryInner);
diff --git a/frontend/src/metabase/admin/datamodel/containers/SegmentApp.tsx b/frontend/src/metabase/admin/datamodel/containers/SegmentApp.tsx
index c285625f831..b2958e05679 100644
--- a/frontend/src/metabase/admin/datamodel/containers/SegmentApp.tsx
+++ b/frontend/src/metabase/admin/datamodel/containers/SegmentApp.tsx
@@ -2,17 +2,24 @@ import { useCallback, useState } from "react";
import type { Route } from "react-router";
import { push } from "react-router-redux";
import { t } from "ttag";
-import _ from "underscore";
+import {
+ useCreateSegmentMutation,
+ useGetSegmentQuery,
+ useUpdateSegmentMutation,
+} from "metabase/api";
import { LeaveRouteConfirmModal } from "metabase/common/components/LeaveConfirmModal";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import { useCallbackEffect } from "metabase/common/hooks/use-callback-effect";
import { trackSegmentCreated } from "metabase/data-studio/analytics";
-import { Segments } from "metabase/entities/segments";
-import { Tables } from "metabase/entities/tables";
+import { useLoadTableWithMetadata } from "metabase/data-studio/common/hooks/use-load-table-with-metadata";
import { useMetadataToasts } from "metabase/metadata/hooks";
-import { connect } from "metabase/redux";
-import type { State } from "metabase/redux/store";
-import type { Segment } from "metabase-types/api";
+import { useDispatch } from "metabase/redux";
+import type {
+ CreateSegmentRequest,
+ Segment,
+ UpdateSegmentRequest,
+} from "metabase-types/api";
import { SegmentForm } from "../components/SegmentForm";
@@ -23,62 +30,54 @@ type SegmentAppOwnProps = {
route: Route;
};
-type NormalizedSegmentResponse = {
- payload: {
- segment: Segment;
- };
+type UpdateSegmentFormProps = {
+ route: Route;
+ segmentId: number;
};
-type SegmentAppDispatchProps = {
- createSegment: (
- segment: Partial<Segment>,
- ) => Promise<NormalizedSegmentResponse>;
- updateSegment: (
- segment: Partial<Segment>,
- ) => Promise<NormalizedSegmentResponse>;
- onChangeLocation: (path: string) => void;
-};
+function UpdateSegmentForm({ route, segmentId }: UpdateSegmentFormProps) {
+ const dispatch = useDispatch();
+ const [isDirty, setIsDirty] = useState(false);
+ const [updateSegment] = useUpdateSegmentMutation();
-const mapDispatchToProps: SegmentAppDispatchProps = {
- createSegment: Segments.actions.create,
- updateSegment: Segments.actions.update,
- onChangeLocation: push,
-};
+ const {
+ data: segment,
+ isLoading: isLoadingSegment,
+ error: segmentError,
+ } = useGetSegmentQuery(segmentId);
-type UpdateSegmentFormInnerProps = SegmentAppOwnProps &
- SegmentAppDispatchProps & {
- segment: Segment & {
- // Attributes from entity framework object wrapper
- getPlainObject(): Segment;
- };
- };
-
-function UpdateSegmentFormInner({
- route,
- segment,
- updateSegment,
- onChangeLocation,
-}: UpdateSegmentFormInnerProps) {
- const [isDirty, setIsDirty] = useState(false);
+ const { isLoading: isLoadingTable, error: tableError } =
+ useLoadTableWithMetadata(segment?.table_id, {
+ includeForeignTables: true,
+ });
const handleSubmit = useCallback(
async (segmentValues: Partial<Segment>) => {
setIsDirty(false);
- try {
- await updateSegment(segmentValues);
- onChangeLocation("/admin/datamodel/segments");
- } catch {
+ const result = await updateSegment(
+ toUpdateSegmentRequest(segmentId, segmentValues),
+ );
+ if (result.error) {
setIsDirty(isDirty);
+ return;
}
+ dispatch(push("/admin/datamodel/segments"));
},
- [updateSegment, isDirty, onChangeLocation],
+ [dispatch, segmentId, updateSegment, isDirty],
);
+ const isLoading = isLoadingSegment || isLoadingTable;
+ const error = segmentError ?? tableError;
+
+ if (isLoading || error || !segment) {
+ return <LoadingAndErrorWrapper loading={isLoading} error={error} />;
+ }
+
return (
<>
<SegmentForm
- segment={segment.getPlainObject()}
+ segment={segment}
onIsDirtyChange={setIsDirty}
onSubmit={handleSubmit}
/>
@@ -88,29 +87,15 @@ function UpdateSegmentFormInner({
);
}
-const UpdateSegmentForm = _.compose(
- Segments.load({
- id: (_state: State, { params }: SegmentAppOwnProps) =>
- parseInt(params.id, 10),
- }),
- Tables.load({
- id: (_state: State, { segment }: { segment?: Segment }) =>
- segment?.table_id,
- fetchType: "fetchMetadataAndForeignTables",
- requestType: "fetchMetadataDeprecated",
- }),
-)(UpdateSegmentFormInner);
-
-type CreateSegmentFormProps = SegmentAppOwnProps & SegmentAppDispatchProps;
-
-function CreateSegmentForm({
- createSegment,
- route,
- onChangeLocation,
- ...props
-}: CreateSegmentFormProps) {
+type CreateSegmentFormProps = {
+ route: Route;
+};
+
+function CreateSegmentForm({ route }: CreateSegmentFormProps) {
+ const dispatch = useDispatch();
const [isDirty, setIsDirty] = useState(false);
const { sendErrorToast } = useMetadataToasts();
+ const [createSegment] = useCreateSegmentMutation();
/**
* Navigation is scheduled so that LeaveConfirmationModal's isEnabled
@@ -123,52 +108,54 @@ function CreateSegmentForm({
setIsDirty(false);
scheduleCallback(async () => {
- try {
- const { payload } = await createSegment(segment);
- trackSegmentCreated(
- "success",
- "admin_datamodel_segments",
- payload.segment?.id,
- );
- onChangeLocation("/admin/datamodel/segments");
- } catch (error) {
+ const result = await createSegment(segment as CreateSegmentRequest);
+ if (result.error) {
sendErrorToast(t`Failed to create segment`);
trackSegmentCreated("failure", "admin_datamodel_segments");
setIsDirty(isDirty);
- console.warn(error);
+ console.warn(result.error);
+ return;
}
+ trackSegmentCreated(
+ "success",
+ "admin_datamodel_segments",
+ result.data?.id,
+ );
+ dispatch(push("/admin/datamodel/segments"));
});
},
- [
- scheduleCallback,
- createSegment,
- onChangeLocation,
- sendErrorToast,
- isDirty,
- ],
+ [scheduleCallback, createSegment, dispatch, sendErrorToast, isDirty],
);
return (
<>
- <SegmentForm
- {...props}
- onIsDirtyChange={setIsDirty}
- onSubmit={handleSubmit}
- />
+ <SegmentForm onIsDirtyChange={setIsDirty} onSubmit={handleSubmit} />
<LeaveRouteConfirmModal isEnabled={isDirty} route={route} />
</>
);
}
-type SegmentAppInnerProps = SegmentAppOwnProps & SegmentAppDispatchProps;
-
-function SegmentAppInner(props: SegmentAppInnerProps) {
- if (props.params.id) {
- return <UpdateSegmentForm {...props} />;
+export function SegmentApp({ params, route }: SegmentAppOwnProps) {
+ if (params.id) {
+ return (
+ <UpdateSegmentForm route={route} segmentId={parseInt(params.id, 10)} />
+ );
}
- return <CreateSegmentForm {...props} />;
+ return <CreateSegmentForm route={route} />;
}
-export const SegmentApp = connect(null, mapDispatchToProps)(SegmentAppInner);
+function toUpdateSegmentRequest(
+ id: number,
+ values: Partial<Segment>,
+): UpdateSegmentRequest {
+ return {
+ id,
+ name: values.name,
+ description: values.description,
+ definition: values.definition,
+ archived: values.archived,
+ revision_message: values.revision_message ?? "",
+ };
+}
diff --git a/frontend/src/metabase/admin/datamodel/containers/SegmentListApp.tsx b/frontend/src/metabase/admin/datamodel/containers/SegmentListApp.tsx
index c800b5418f3..4bb3b4b039b 100644
--- a/frontend/src/metabase/admin/datamodel/containers/SegmentListApp.tsx
+++ b/frontend/src/metabase/admin/datamodel/containers/SegmentListApp.tsx
@@ -1,37 +1,36 @@
import cx from "classnames";
+import type { Location } from "history";
import type { ReactNode } from "react";
import { t } from "ttag";
-import _ from "underscore";
import { SegmentItem } from "metabase/admin/datamodel/components/SegmentItem";
import { FilteredToUrlTable } from "metabase/admin/datamodel/hoc/FilteredToUrlTable";
+import { useListSegmentsQuery } from "metabase/api";
import { Button } from "metabase/common/components/Button";
import { Link } from "metabase/common/components/Link";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
import { useSetArchive } from "metabase/common/hooks";
import AdminS from "metabase/css/admin.module.css";
import CS from "metabase/css/core/index.css";
import { trackSegmentCreateStarted } from "metabase/data-studio/analytics";
-import { Segments } from "metabase/entities/segments";
import { PLUGIN_REMOTE_SYNC } from "metabase/plugins";
-import { connect } from "metabase/redux";
-import type { State } from "metabase/redux/store";
+import { useSelector } from "metabase/redux";
+import { getShallowTables } from "metabase/selectors/metadata";
import { getUserIsAdmin } from "metabase/selectors/user";
import * as Urls from "metabase/urls";
import type { Segment } from "metabase-types/api";
interface Props {
- isAdmin: boolean;
- isRemoteSyncReadOnly: boolean;
segments: Segment[];
tableSelector: ReactNode;
}
-function SegmentListAppInner({
- isAdmin,
- isRemoteSyncReadOnly,
- segments,
- tableSelector,
-}: Props) {
+function SegmentListAppInner({ segments, tableSelector }: Props) {
+ const isAdmin = useSelector(getUserIsAdmin);
+ const isRemoteSyncReadOnly = useSelector(
+ PLUGIN_REMOTE_SYNC.getIsRemoteSyncReadOnly,
+ );
+ const tables = useSelector(getShallowTables);
const archive = useSetArchive();
const trackSegmentCreateClick = () => {
trackSegmentCreateStarted("admin_datamodel_segments");
@@ -71,7 +70,9 @@ function SegmentListAppInner({
<SegmentItem
key={segment.id}
segment={segment}
- readOnly={segment.table?.is_published && isRemoteSyncReadOnly}
+ readOnly={
+ tables[segment.table_id]?.is_published && isRemoteSyncReadOnly
+ }
onRetire={
isAdmin
? () => archive({ id: segment.id, model: "segment" }, true)
@@ -91,11 +92,18 @@ function SegmentListAppInner({
);
}
-export const SegmentListApp = _.compose(
- Segments.loadList(),
- FilteredToUrlTable,
- connect((state: State) => ({
- isAdmin: getUserIsAdmin(state),
- isRemoteSyncReadOnly: PLUGIN_REMOTE_SYNC.getIsRemoteSyncReadOnly(state),
- })),
-)(SegmentListAppInner);
+const FilteredSegmentList = FilteredToUrlTable(SegmentListAppInner);
+
+type SegmentListAppProps = {
+ location: Location<{ table?: string }>;
+};
+
+export function SegmentListApp({ location }: SegmentListAppProps) {
+ const { data: segments, isLoading, error } = useListSegmentsQuery();
+
+ if (isLoading || error || !segments) {
+ return <LoadingAndErrorWrapper loading={isLoading} error={error} />;
+ }
+
+ return <FilteredSegmentList location={location} segments={segments} />;
+}
diff --git a/frontend/src/metabase/entities/index.ts b/frontend/src/metabase/entities/index.ts
index d54c8bf795f..7f7d744b61a 100644
--- a/frontend/src/metabase/entities/index.ts
+++ b/frontend/src/metabase/entities/index.ts
@@ -78,7 +78,6 @@ export { Databases as databases } from "./databases";
export { Schemas as schemas } from "./schemas";
export { Tables as tables } from "./tables";
export { Fields as fields } from "./fields";
-export { Segments as segments } from "./segments";
export { Measures as measures } from "./measures";
export { Snippets as snippets } from "./snippets";
diff --git a/frontend/src/metabase/entities/segments.js b/frontend/src/metabase/entities/segments.js
deleted file mode 100644
index 992238d4de0..00000000000
--- a/frontend/src/metabase/entities/segments.js
+++ /dev/null
@@ -1,66 +0,0 @@
-import {
- segmentApi,
- useGetSegmentQuery,
- useListSegmentsQuery,
-} from "metabase/api";
-import { SegmentSchema } from "metabase/schema";
-import { getMetadata } from "metabase/selectors/metadata";
-
-import { createEntity, entityCompatibleQuery } from "./utils";
-
-/**
- * @deprecated use "metabase/api" instead
- */
-export const Segments = createEntity({
- name: "segments",
- nameOne: "segment",
- path: "/api/segment",
- schema: SegmentSchema,
-
- rtk: () => ({
- getUseGetQuery: () => ({
- useGetQuery,
- }),
- useListQuery: useListSegmentsQuery,
- }),
-
- api: {
- list: (entityQuery, dispatch) =>
- entityCompatibleQuery(
- entityQuery,
- dispatch,
- segmentApi.endpoints.listSegments,
- ),
- get: (entityQuery, options, dispatch) =>
- entityCompatibleQuery(
- entityQuery.id,
- dispatch,
- segmentApi.endpoints.getSegment,
- ),
- create: (entityQuery, dispatch) =>
- entityCompatibleQuery(
- entityQuery,
- dispatch,
- segmentApi.endpoints.createSegment,
- ),
- update: (entityQuery, dispatch) =>
- entityCompatibleQuery(
- entityQuery,
- dispatch,
- segmentApi.endpoints.updateSegment,
- ),
- },
-
- objectActions: {
- // NOTE: DELETE not currently implemented
- delete: null,
- },
-
- selectors: {
- getObject: (state, { entityId }) => getMetadata(state).segment(entityId),
- },
-});
-
-const useGetQuery = ({ id }, options) => {
- return useGetSegmentQuery(id, options);
-};
diff --git a/frontend/src/metabase/entities/tables.js b/frontend/src/metabase/entities/tables.js
index a5a3425b2c7..16c260f3316 100644
--- a/frontend/src/metabase/entities/tables.js
+++ b/frontend/src/metabase/entities/tables.js
@@ -17,7 +17,6 @@ import {
} from "metabase/api";
import { Fields } from "metabase/entities/fields";
import { Questions } from "metabase/entities/questions";
-import { Segments } from "metabase/entities/segments";
import {
compose,
createThunkAction,
@@ -310,31 +309,6 @@ export const Tables = createEntity({
};
}
- if (type === Segments.actionTypes.CREATE) {
- const { table_id: tableId, id: segmentId } = payload.segment;
- const table = state[tableId];
- if (table) {
- return {
- ...state,
- [tableId]: { ...table, segments: [segmentId, ...table.segments] },
- };
- }
- }
-
- if (type === Segments.actionTypes.UPDATE && !error) {
- const { table_id: tableId, archived, id: segmentId } = payload.segment;
- const table = state[tableId];
- if (archived && table && table.segments) {
- return {
- ...state,
- [tableId]: {
- ...table,
- segments: table.segments.filter((id) => id !== segmentId),
- },
- };
- }
- }
-
if (type === UPDATE_TABLE_FIELD_ORDER) {
const table = state[payload.id];
if (table) {
diff --git a/frontend/src/metabase/entities/utils.ts b/frontend/src/metabase/entities/utils.ts
index dffb2cf60df..2e226db5b00 100644
--- a/frontend/src/metabase/entities/utils.ts
+++ b/frontend/src/metabase/entities/utils.ts
@@ -973,7 +973,7 @@ type CombinedEntities = {
* another entity's normalizr schema (e.g. measures inside a table's
* `query_metadata` response).
*/
-const RETIRED_ENTITY_NAMES = ["metrics"];
+const RETIRED_ENTITY_NAMES = ["metrics", "segments"];
export function combineEntities(entities: Entity[]): CombinedEntities {
const entitiesMap: Record<string, Entity> = {};
diff --git a/frontend/src/metabase/redux/metadata.js b/frontend/src/metabase/redux/metadata.js
index 863036f65af..cecd27c65d4 100644
--- a/frontend/src/metabase/redux/metadata.js
+++ b/frontend/src/metabase/redux/metadata.js
@@ -1,10 +1,9 @@
import { getIn } from "icepick";
import _ from "underscore";
-import { cardApi, dashboardApi, datasetApi } from "metabase/api";
+import { cardApi, dashboardApi, datasetApi, segmentApi } from "metabase/api";
import { Databases } from "metabase/entities/databases";
import { Fields } from "metabase/entities/fields";
-import { Segments } from "metabase/entities/segments";
import { Tables } from "metabase/entities/tables";
import { entityCompatibleQuery } from "metabase/entities/utils";
import { isProduction } from "metabase/env";
@@ -22,15 +21,22 @@ const deprecated = (message) => {
}
};
-export const FETCH_SEGMENTS = Segments.actions.fetchList.toString();
-export const fetchSegments = (reload = false) => {
+export const fetchSegments = () => (dispatch) => {
deprecated("metabase/redux/metadata fetchSegments");
- return Segments.actions.fetchList(null, { reload });
+ return entityCompatibleQuery(
+ undefined,
+ dispatch,
+ segmentApi.endpoints.listSegments,
+ );
};
-export const updateSegment = (segment) => {
+export const updateSegment = (segment) => (dispatch) => {
deprecated("metabase/redux/metadata updateSegment");
- return Segments.actions.update(segment);
+ return entityCompatibleQuery(
+ segment,
+ dispatch,
+ segmentApi.endpoints.updateSegment,
+ );
};
export const fetchRealDatabases = (reload = false) => {
diff --git a/frontend/src/metabase/selectors/metadata.ts b/frontend/src/metabase/selectors/metadata.ts
index 360ff83651e..00336985072 100644
--- a/frontend/src/metabase/selectors/metadata.ts
+++ b/frontend/src/metabase/selectors/metadata.ts
@@ -10,7 +10,6 @@ import ForeignKey from "metabase-lib/v1/metadata/ForeignKey";
import Measure from "metabase-lib/v1/metadata/Measure";
import Metadata from "metabase-lib/v1/metadata/Metadata";
import Schema from "metabase-lib/v1/metadata/Schema";
-import Segment from "metabase-lib/v1/metadata/Segment";
import Table from "metabase-lib/v1/metadata/Table";
import { isVirtualCardId } from "metabase-lib/v1/metadata/utils/saved-questions";
import {
@@ -30,6 +29,7 @@ import type {
NormalizedSchema,
NormalizedSegment,
NormalizedTable,
+ Segment,
} from "metabase-types/api";
import { getSettings } from "./settings";
@@ -150,7 +150,7 @@ export const getMetadata: (
.map((f) => [f.uniqueId, createField(f, metadata)]),
);
metadata.segments = Object.fromEntries(
- Object.values(segments).map((s) => [s.id, createSegment(s, metadata)]),
+ Object.values(segments).map((s) => [s.id, createSegment(s)]),
);
metadata.measures = Object.fromEntries(
Object.values(measures).map((m) => [m.id, createMeasure(m, metadata)]),
@@ -186,9 +186,6 @@ export const getMetadata: (
Object.values(metadata.schemas).forEach((schema) => {
schema.tables = hydrateSchemaTables(schema, metadata);
});
- Object.values(metadata.segments).forEach((segment) => {
- segment.table = hydrateSegmentTable(segment, metadata);
- });
Object.values(metadata.measures).forEach((measure) => {
measure.table = hydrateMeasureTable(measure, metadata);
});
@@ -267,13 +264,9 @@ function createForeignKey(
return instance;
}
-function createSegment(
- segment: NormalizedSegment,
- metadata: Metadata,
-): Segment {
- const instance = new Segment(segment);
- instance.metadata = metadata;
- return instance;
+function createSegment(segment: NormalizedSegment): Segment {
+ const { table: _normalizedTableId, ...rest } = segment;
+ return rest;
}
function createMeasure(
@@ -399,7 +392,9 @@ function hydrateTableForeignKeys(
function hydrateTableSegments(table: Table, metadata: Metadata): Segment[] {
const segmentIds = table.getPlainObject().segments ?? [];
- return segmentIds.map((id) => metadata.segment(id)).filter(isNotNull);
+ return segmentIds
+ .map((id) => metadata.segments[id] ?? null)
+ .filter(isNotNull);
}
function hydrateTableMeasures(table: Table, metadata: Metadata): Measure[] {
@@ -433,13 +428,6 @@ function hydrateNameField(field: Field, metadata: Metadata): Field | undefined {
}
}
-function hydrateSegmentTable(
- segment: Segment,
- metadata: Metadata,
-): Table | undefined {
- return metadata.table(segment.table_id) ?? undefined;
-}
-
function hydrateMeasureTable(
measure: Measure,
metadata: Metadata,