@truedat/dd 4.37.2 → 4.37.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [4.37.3] 2022-02-03
+
+### Changed
+
+- [TD-2929] `StructureUserFilter` specific functionality is now the
+  generic `UserSearchFilter` used by DataQuality entities
+
 ## [4.37.0] 2022-01-25
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/dd",
-  "version": "4.37.2",
+  "version": "4.37.3",
   "description": "Truedat Web Data Dictionary",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -84,9 +84,9 @@
     ]
   },
   "dependencies": {
-    "@truedat/auth": "4.37.2",
-    "@truedat/core": "4.37.2",
-    "@truedat/df": "4.37.2",
+    "@truedat/auth": "4.37.3",
+    "@truedat/core": "4.37.3",
+    "@truedat/df": "4.37.3",
     "lodash": "^4.17.21",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.7.2",
@@ -107,5 +107,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "ca6ba01d31ab5ec415b9b21d6ce02b418fc6e0ff"
+  "gitHead": "1c418784d34e171a6d62dd7fab3dfd05400998ba"
 }

package/src/api.js

@@ -34,10 +34,9 @@ const API_STRUCTURE_TYPES = "/api/data_structure_types";
 const API_STRUCTURE_TYPES_LITE = "/api/data_structure_types/lite";
 const API_STRUCTURES_TAG = "/api/data_structures/:data_structure_id/tags/:id";
 const API_STRUCTURES_TAGS = "/api/data_structures/:data_structure_id/tags";
-const API_STRUCTURE_USER_FILTERS = "/api/data_structure_user_filters";
-const API_STRUCTURE_USER_FILTER = "/api/data_structure_user_filters/:id";
-const API_GET_STRUCTURE_USER_FILTERS =
-  "/api/data_structure_user_filters/user/me";
+const API_USER_SEARCH_FILTERS = "/api/user_search_filters";
+const API_USER_SEARCH_FILTER = "/api/user_search_filters/:id";
+const API_GET_USER_SEARCH_FILTERS = "/api/user_search_filters/me";
 const API_STRUCTURES_UPLOAD =
   "/api/data_structures/bulk_update_template_content";
 const API_STRUCTURE_NOTE = "/api/data_structures/:data_structure_id/notes/:id";
@@ -79,11 +78,11 @@ export {
   API_STRUCTURE_TYPE,
   API_STRUCTURE_TYPES,
   API_STRUCTURE_TYPES_LITE,
-  API_STRUCTURE_USER_FILTERS,
-  API_STRUCTURE_USER_FILTER,
+  API_USER_SEARCH_FILTERS,
+  API_USER_SEARCH_FILTER,
+  API_GET_USER_SEARCH_FILTERS,
   API_STRUCTURES_TAG,
   API_STRUCTURES_TAGS,
-  API_GET_STRUCTURE_USER_FILTERS,
   API_STRUCTURES_UPLOAD,
   API_STRUCTURE_NOTE,
   API_STRUCTURE_NOTES,

package/src/components/StructureSelectedFilters.js

@@ -5,13 +5,13 @@ import { injectIntl } from "react-intl";
 import { SelectedFilters } from "@truedat/core/components";
 import { makeOption } from "@truedat/core/services/i18n";
 import {
-  applyStructureUserFilter,
+  applyUserSearchFilter,
   closeStructureFilter,
-  deleteStructureUserFilter,
+  deleteUserSearchFilter,
   openStructureFilter,
   removeStructureFilter,
   resetStructureFilters,
-  saveStructureUserFilters,
+  saveUserSearchFilters,
   toggleStructureFilterValue,
 } from "../routines";
 import {
@@ -53,9 +53,11 @@ export const mapStateToProps = (state, ownProps) => {
     getStructureSelectedFilterActiveValues(state);
   const selectedFilters = getStructureSelectedFilters(state);
   const structureTypes = _.prop("structureTypes")(state);
-  const { structureSelectedUserFilter: selectedUserFilter } = state;
-  const { structureActiveFilters: activeFilters } = state;
-  const { structureUserFilters: userFilters } = state;
+  const {
+    selectedUserSearchFilter: selectedUserFilter,
+    structureActiveFilters: activeFilters,
+    userSearchFilters: userFilters,
+  } = state;
   return {
     loading,
     selectedFilter,
@@ -67,19 +69,20 @@ export const mapStateToProps = (state, ownProps) => {
     selectedUserFilter,
     activeFilters,
     userFilters,
+    userFilterScope: "data_structure",
   };
 };
 
 const mapDispatchToProps = (dispatch) =>
   bindActionCreators(
     {
-      applyUserFilter: applyStructureUserFilter,
+      applyUserFilter: applyUserSearchFilter,
       closeFilter: closeStructureFilter,
-      deleteUserFilter: deleteStructureUserFilter,
+      deleteUserFilter: deleteUserSearchFilter,
       openFilter: openStructureFilter,
       removeFilter: removeStructureFilter,
       resetFilters: resetStructureFilters,
-      saveFilters: saveStructureUserFilters,
+      saveFilters: saveUserSearchFilters,
       toggleFilterValue: toggleStructureFilterValue,
     },
     dispatch

package/src/components/StructureSelector.js

@@ -8,7 +8,7 @@ import StructureDateFilter from "./StructureDateFilter";
 import StructureFiltersLoader from "./StructureFiltersLoader";
 import StructureSelectedFilters from "./StructureSelectedFilters";
 import StructureTypesLoader from "./StructureTypesLoader";
-import StructureUserFiltersLoader from "./StructureUserFiltersLoader";
+import UserSearchFiltersLoader from "./UserSearchFiltersLoader";
 import StructuresLoader from "./StructuresLoader";
 import StructuresSearch from "./StructuresSearch";
 import StructuresSearchResults from "./StructuresSearchResults";
@@ -40,7 +40,7 @@ export const StructureSelector = ({
       <StructuresSearch />
       <StructureSelectedFilters />
       <StructureDateFilter />
-      <StructureUserFiltersLoader />
+      <UserSearchFiltersLoader scope="data_structure" />
       <StructuresSearchResults
         columns={!_.isEmpty(overwriteColumns) ? overwriteColumns : columns}
         loading={loading}

package/src/components/StructuresRoutes.js

@@ -14,7 +14,7 @@ import {
 import DomainsLoader from "@truedat/bg/taxonomy/components/DomainsLoader";
 import StructureCrumbs from "./StructureCrumbs";
 import StructureLoader from "./StructureLoader";
-import StructureUserFiltersLoader from "./StructureUserFiltersLoader";
+import UserSearchFiltersLoader from "./UserSearchFiltersLoader";
 import StructureTagsLoader from "./StructureTagsLoader";
 import StructureView from "./StructureView";
 import StructuresBulkUpdate from "./StructuresBulkUpdate";
@@ -71,7 +71,7 @@ const AuthorizedRoutes = () => {
         path={STRUCTURES}
         render={() => (
           <>
-            <StructureUserFiltersLoader />
+            <UserSearchFiltersLoader scope="data_structure" />
             <UserDomainsLoader
               permissions={[
                 "publish_structure_note_from_draft",

package/src/components/UserSearchFiltersLoader.js

@@ -0,0 +1,29 @@
+import { useEffect } from "react";
+import PropTypes from "prop-types";
+import { connect } from "react-redux";
+import { clearUserSearchFilters, fetchUserSearchFilters } from "../routines";
+
+export const UserSearchFiltersLoader = ({
+  clearUserSearchFilters,
+  fetchUserSearchFilters,
+  scope,
+}) => {
+  useEffect(() => {
+    fetchUserSearchFilters(scope);
+    return () => {
+      clearUserSearchFilters();
+    };
+  }, [clearUserSearchFilters, fetchUserSearchFilters]);
+  return null;
+};
+
+UserSearchFiltersLoader.propTypes = {
+  clearUserSearchFilters: PropTypes.func,
+  fetchUserSearchFilters: PropTypes.func,
+  scope: PropTypes.string,
+};
+
+export default connect(null, {
+  clearUserSearchFilters,
+  fetchUserSearchFilters,
+})(UserSearchFiltersLoader);

package/src/components/__tests__/UserSearchFiltersLoader.spec.js

@@ -0,0 +1,27 @@
+import React from "react";
+import { shallow, mount } from "enzyme";
+import { UserSearchFiltersLoader } from "../UserSearchFiltersLoader";
+
+describe("<UserSearchFiltersLoader />", () => {
+  const fetchUserSearchFilters = jest.fn();
+  const clearUserSearchFilters = jest.fn();
+
+  it("matches the latest snapshot", () => {
+    const props = { clearUserSearchFilters, fetchUserSearchFilters };
+    const wrapper = shallow(<UserSearchFiltersLoader {...props} />);
+    expect(wrapper).toMatchSnapshot();
+  });
+
+  it("calls fetchUserSearchFilters when component mounts, clearUserSearchFilters when component unmounts", () => {
+    const fetchUserSearchFilters = jest.fn();
+    const clearUserSearchFilters = jest.fn();
+
+    const props = { fetchUserSearchFilters, clearUserSearchFilters };
+    const wrapper = mount(<UserSearchFiltersLoader {...props} />);
+    expect(clearUserSearchFilters.mock.calls.length).toBe(0);
+    expect(fetchUserSearchFilters.mock.calls.length).toBe(1);
+    wrapper.unmount();
+    expect(clearUserSearchFilters.mock.calls.length).toBe(1);
+    expect(fetchUserSearchFilters.mock.calls.length).toBe(1);
+  });
+});

package/src/components/__tests__/__snapshots__/StructureSelector.spec.js.snap

@@ -12,7 +12,9 @@ exports[`<StructureSelector /> matches the latest snapshot 1`] = `
   <Connect(StructuresSearch) />
   <injectIntl(Connect(SelectedFilters)) />
   <Connect(StructureDateFilter) />
-  <Connect(StructureUserFiltersLoader) />
+  <Connect(UserSearchFiltersLoader)
+    scope="data_structure"
+  />
   <StructuresSearchResults
     columns={
       Array [

package/src/components/__tests__/__snapshots__/UserSearchFiltersLoader.spec.js.snap

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`<UserSearchFiltersLoader /> matches the latest snapshot 1`] = `""`;

package/src/messages/en.js

@@ -2,7 +2,7 @@ export default {
   "alert.createStructureTag.failed.header": "Error creating structure tag",
   "alert.export.csv": "Export to CSV",
   "alert.linkStructureTag.failed.header": "Error linking tag to structure",
-  "alert.saveStructureUserFilters.failed.header": "Error saving filter",
+  "alert.saveUserSearchFilters.failed.header": "Error saving filter",
   "alert.show.more": "Show more",
   "alert.updateStructureTag.failed.header": "Error editing structure tag",
   "alert.updateSystem.failed.header": "Error updating system",
@@ -163,7 +163,7 @@ export default {
   "profiling.field.name": "Name",
   "profiling.field.null": "Nulls",
   "profiling.field.unique": "Uniques",
-  "saveStructureUserFilters.error.name.duplicated": "Duplicated name",
+  "saveUserSearchFilters.error.name.duplicated": "Duplicated name",
   "structure._actions": " ",
   "structure.actions.delete.confirmation.content":
     "This structure and all its descendant structures will be deleted. Are you sure?",

package/src/messages/es.js

@@ -3,7 +3,7 @@ export default {
   "alert.export.csv": "Exportar a CSV",
   "alert.linkStructureTag.failed.header":
     "Error asociando etiqueta a estructura",
-  "alert.saveStructureUserFilters.failed.header": "Error guardando filtro",
+  "alert.saveUserSearchFilters.failed.header": "Error guardando filtro",
   "alert.show.more": "Mostrar más",
   "alert.updateStructureTag.failed.header": "Error al editar Etiqueta",
   "alert.updateSystem.failed.header": "Error actualizando sistema",
@@ -166,7 +166,7 @@ export default {
   "profiling.field.name": "Nombre",
   "profiling.field.null": "Nulos",
   "profiling.field.unique": "Únicos",
-  "saveStructureUserFilters.error.name.duplicated": "Nombre duplicado",
+  "saveUserSearchFilters.error.name.duplicated": "Nombre duplicado",
   "structure._actions": " ",
   "structure.actions.delete.confirmation.content":
     "Se va a borrar esta estructura y todas las estructuras descendientes. ¿Está seguro?",

package/src/reducers/__tests__/grantQuery.spec.js

@@ -47,15 +47,6 @@ describe("reducers: grantQuery", () => {
     });
   });
 
-  // // it("should return default page when user filter is applied", () => {
-  // //   expect(
-  // //     grantQuery(fooState, { type: applyStructureUserFilter.TRIGGER })
-  // //   ).toEqual({
-  // //     ...fooState,
-  // //     page: 1
-  // //   });
-  // // });
-
   it("should return default page when filter is toggled", () => {
     expect(
       grantQuery(fooState, { type: toggleGrantFilterValue.TRIGGER })

package/src/reducers/__tests__/selectedUserSearchFilter.spec.js

@@ -0,0 +1,62 @@
+import { initialState } from "../selectedUserSearchFilter";
+import {
+  applyUserSearchFilter,
+  clearUserSearchFilters,
+  removeStructureFilter,
+  resetStructureFilters,
+} from "../../routines";
+import { selectedUserSearchFilter } from "..";
+
+const fooState = { foo: "bar" };
+
+describe("reducers: structureActiveFilters", () => {
+  it("should provide the initial state", () => {
+    expect(selectedUserSearchFilter(undefined, {})).toEqual(initialState);
+  });
+
+  it("should handle the applyUserSearchFilter.TRIGGER action", () => {
+    const name = "by country";
+    const payload = { userFilter: { name } };
+    expect(
+      selectedUserSearchFilter(fooState, {
+        type: applyUserSearchFilter.TRIGGER,
+        payload,
+      })
+    ).toEqual(name);
+
+    expect(
+      selectedUserSearchFilter(name, {
+        type: applyUserSearchFilter.TRIGGER,
+        payload,
+      })
+    ).toEqual(null);
+  });
+
+  it("should handle the removeStructureFilter.TRIGGER action", () => {
+    expect(
+      selectedUserSearchFilter(fooState, {
+        type: removeStructureFilter.TRIGGER,
+      })
+    ).toEqual(initialState);
+  });
+
+  it("should handle the resetStructureFilters.TRIGGER action", () => {
+    expect(
+      selectedUserSearchFilter(fooState, {
+        type: resetStructureFilters.TRIGGER,
+      })
+    ).toEqual(initialState);
+  });
+
+  it("should handle the clearUserSearchFilters.TRIGGER action", () => {
+    expect(
+      selectedUserSearchFilter(fooState, {
+        type: clearUserSearchFilters.TRIGGER,
+      })
+    ).toEqual(initialState);
+  });
+
+  it("should ignore unknown actions", () => {
+    expect(selectedUserSearchFilter(fooState, { type: "FOO" })).toBe(fooState);
+  });
+});

package/src/reducers/__tests__/structureActiveFilters.spec.js

@@ -1,12 +1,12 @@
 import { initialState } from "../structureActiveFilters";
 import {
   addStructureFilter,
-  applyStructureUserFilter,
+  applyUserSearchFilter,
   clearStructureFilters,
   closeStructureFilter,
   removeStructureFilter,
   resetStructureFilters,
-  toggleStructureFilterValue
+  toggleStructureFilterValue,
 } from "../../routines";
 import { structureActiveFilters } from "..";
 
@@ -20,7 +20,7 @@ describe("reducers: structureActiveFilters", () => {
   it("should handle the clearStructureFilters.TRIGGER action", () => {
     expect(
       structureActiveFilters(fooState, {
-        type: clearStructureFilters.TRIGGER
+        type: clearStructureFilters.TRIGGER,
       })
     ).toEqual(initialState);
   });
@@ -31,18 +31,18 @@ describe("reducers: structureActiveFilters", () => {
     expect(
       structureActiveFilters(fooState, {
         type: addStructureFilter.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ ...fooState, baz: [] });
   });
 
-  it("should handle the applyStructureUserFilter.TRIGGER action", () => {
+  it("should handle the applyUserSearchFilter.TRIGGER action", () => {
     const filters = { country: ["Sp"] };
-    const payload = { userFilter: { filters } };
+    const payload = { userFilter: { filters }, scope: "data_structure" };
     expect(
       structureActiveFilters(fooState, {
-        type: applyStructureUserFilter.TRIGGER,
-        payload
+        type: applyUserSearchFilter.TRIGGER,
+        payload,
       })
     ).toEqual({ ...filters });
   });
@@ -55,7 +55,7 @@ describe("reducers: structureActiveFilters", () => {
     expect(
       structureActiveFilters(state, {
         type: closeStructureFilter.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ foo });
   });
@@ -68,7 +68,7 @@ describe("reducers: structureActiveFilters", () => {
     expect(
       structureActiveFilters(state, {
         type: removeStructureFilter.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ bar });
   });
@@ -76,7 +76,7 @@ describe("reducers: structureActiveFilters", () => {
   it("should handle the resetStructureFilters.TRIGGER action", () => {
     expect(
       structureActiveFilters(fooState, {
-        type: resetStructureFilters.TRIGGER
+        type: resetStructureFilters.TRIGGER,
       })
     ).toEqual(initialState);
   });
@@ -89,7 +89,7 @@ describe("reducers: structureActiveFilters", () => {
     expect(
       structureActiveFilters(state, {
         type: toggleStructureFilterValue.TRIGGER,
-        payload
+        payload,
       })
     ).toEqual({ foo: ["foo1", "foo3"], bar });
   });

package/src/reducers/__tests__/structureQuery.spec.js

@@ -1,12 +1,12 @@
 import {
-  applyStructureUserFilter,
+  applyUserSearchFilter,
   clearStructureFilters,
   removeStructureFilter,
   searchStructures,
   selectStructurePage,
   sortStructures,
   toggleStructureFilterValue,
-  clearStructuresSort
+  clearStructuresSort,
 } from "../../routines";
 import { initialState } from "../structureQuery";
 import { structureQuery } from "..";
@@ -32,7 +32,7 @@ describe("reducers: structureQuery", () => {
     ).toEqual({
       ...fooState,
       page: 1,
-      query: ""
+      query: "",
     });
   });
 
@@ -41,7 +41,7 @@ describe("reducers: structureQuery", () => {
       structureQuery(fooState, { type: clearStructuresSort.TRIGGER })
     ).toEqual({
       ...fooState,
-      sort: [{ "name.raw": "asc" }]
+      sort: [{ "name.raw": "asc" }],
     });
   });
 
@@ -50,16 +50,16 @@ describe("reducers: structureQuery", () => {
       structureQuery(fooState, { type: removeStructureFilter.TRIGGER })
     ).toEqual({
       ...fooState,
-      page: 1
+      page: 1,
     });
   });
 
   it("should return default page when user filter is applied", () => {
     expect(
-      structureQuery(fooState, { type: applyStructureUserFilter.TRIGGER })
+      structureQuery(fooState, { type: applyUserSearchFilter.TRIGGER })
     ).toEqual({
       ...fooState,
-      page: 1
+      page: 1,
     });
   });
 
@@ -68,7 +68,7 @@ describe("reducers: structureQuery", () => {
       structureQuery(fooState, { type: toggleStructureFilterValue.TRIGGER })
     ).toEqual({
       ...fooState,
-      page: 1
+      page: 1,
     });
   });
 
@@ -96,7 +96,7 @@ describe("reducers: structureQuery", () => {
         structureQuery(fooState, { type: searchStructures.TRIGGER, payload })
       ).toMatchObject({
         query,
-        sort: [{ _score: "desc" }, { "name.raw": "asc" }]
+        sort: [{ _score: "desc" }, { "name.raw": "asc" }],
       });
     });
 
@@ -106,7 +106,7 @@ describe("reducers: structureQuery", () => {
         structureQuery(fooState, { type: searchStructures.TRIGGER, payload })
       ).toMatchObject({
         query: "",
-        sort: [{ "name.raw": "asc" }]
+        sort: [{ "name.raw": "asc" }],
       });
     });
   });

package/src/reducers/__tests__/structureUserFilters.spec.js

@@ -1,39 +1,39 @@
 import _ from "lodash/fp";
 import { accentInsensitivePathOrder } from "@truedat/core/services/sort";
-import { initialState } from "../structureUserFilters";
+import { initialState } from "../userSearchFilters";
 import {
-  fetchStructureUserFilters,
-  clearStructureUserFilters,
-  deleteStructureUserFilter,
-  saveStructureUserFilters
+  fetchUserSearchFilters,
+  clearUserSearchFilters,
+  deleteUserSearchFilter,
+  saveUserSearchFilters,
 } from "../../routines";
-import { structureUserFilters } from "..";
+import { userSearchFilters } from "..";
 
 const fooState = { foo: "bar" };
 
 describe("reducers: structureActiveFilters", () => {
   it("should provide the initial state", () => {
-    expect(structureUserFilters(undefined, {})).toEqual(initialState);
+    expect(userSearchFilters(undefined, {})).toEqual(initialState);
   });
 
-  it("should handle the fetchStructureUserFilters.SUCCESS action", () => {
+  it("should handle the fetchUserSearchFilters.SUCCESS action", () => {
     const filters = [
       { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
+      { name: "a", id: 2, filters: { country: ["S2"] } },
     ];
     const sortedFilters = _.sortBy(accentInsensitivePathOrder("name"))(filters);
     expect(
-      structureUserFilters(fooState, {
-        type: fetchStructureUserFilters.SUCCESS,
-        payload: { data: filters }
+      userSearchFilters(fooState, {
+        type: fetchUserSearchFilters.SUCCESS,
+        payload: { data: filters },
       })
     ).toEqual(sortedFilters);
   });
 
-  it("should handle the saveStructureUserFilters.SUCCESS action", () => {
+  it("should handle the saveUserSearchFilters.SUCCESS action", () => {
     const filters = [
       { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
+      { name: "a", id: 2, filters: { country: ["S2"] } },
     ];
     const newFilter = { name: "c", id: 3, filters: { country: ["S3"] } };
     const sortedFilters = _.flow(
@@ -42,35 +42,35 @@ describe("reducers: structureActiveFilters", () => {
     )(filters);
 
     expect(
-      structureUserFilters(filters, {
-        type: saveStructureUserFilters.SUCCESS,
-        payload: { data: newFilter }
+      userSearchFilters(filters, {
+        type: saveUserSearchFilters.SUCCESS,
+        payload: { data: newFilter },
       })
     ).toEqual(sortedFilters);
   });
 
-  it("should handle the deleteStructureUserFilter.SUCCESS action", () => {
+  it("should handle the deleteUserSearchFilter.SUCCESS action", () => {
     const filters = [
       { name: "b", id: 1, filters: { country: ["S"] } },
-      { name: "a", id: 2, filters: { country: ["S2"] } }
+      { name: "a", id: 2, filters: { country: ["S2"] } },
     ];
     expect(
-      structureUserFilters(filters, {
-        type: deleteStructureUserFilter.SUCCESS,
-        meta: { id: 1 }
+      userSearchFilters(filters, {
+        type: deleteUserSearchFilter.SUCCESS,
+        meta: { id: 1 },
       })
     ).toEqual([{ name: "a", id: 2, filters: { country: ["S2"] } }]);
   });
 
-  it("should handle the clearStructureUserFilters.TRIGGER action", () => {
+  it("should handle the clearUserSearchFilters.TRIGGER action", () => {
     expect(
-      structureUserFilters(fooState, {
-        type: clearStructureUserFilters.TRIGGER
+      userSearchFilters(fooState, {
+        type: clearUserSearchFilters.TRIGGER,
       })
     ).toEqual(initialState);
   });
 
   it("should ignore unknown actions", () => {
-    expect(structureUserFilters(fooState, { type: "FOO" })).toBe(fooState);
+    expect(userSearchFilters(fooState, { type: "FOO" })).toBe(fooState);
   });
 });

package/src/reducers/index.js

@@ -59,7 +59,7 @@ import { structureProfile } from "./structureProfile";
 import { structureQuery } from "./structureQuery";
 import { structureRedirect } from "./structureRedirect";
 import { structureSelectedFilter } from "./structureSelectedFilter";
-import { structureSelectedUserFilter } from "./structureSelectedUserFilter";
+import { selectedUserSearchFilter } from "./selectedUserSearchFilter";
 import { structureSiblings } from "./structureSiblings";
 import { structuresSiblings } from "./structureSiblings";
 import { structureSystem } from "./structureSystem";
@@ -72,7 +72,7 @@ import { structureTypeLoading } from "./structureTypeLoading";
 import { structureTypes } from "./structureTypes";
 import { structureTypesLoading } from "./structureTypesLoading";
 import { structureUpdating } from "./structureUpdating";
-import { structureUserFilters } from "./structureUserFilters";
+import { userSearchFilters } from "./userSearchFilters";
 import { structureVersion } from "./structureVersion";
 import { structureVersions } from "./structureVersions";
 import { structures } from "./structures";
@@ -155,7 +155,7 @@ export {
   structureQuery,
   structureRedirect,
   structureSelectedFilter,
-  structureSelectedUserFilter,
+  selectedUserSearchFilter,
   structureSiblings,
   structureSystem,
   structuresSiblings,
@@ -169,7 +169,7 @@ export {
   structureTypes,
   structureTypesLoading,
   structureUpdating,
-  structureUserFilters,
+  userSearchFilters,
   structureVersion,
   structureVersions,
   structures,