@northern.tech/store 0.1.0

package/storehooks.test.tsx

@@ -0,0 +1,386 @@
+// Copyright 2024 Northern.tech AS
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// @ts-nocheck
+import React from 'react';
+import { Provider } from 'react-redux';
+
+import {
+  getDeploymentsByStatus,
+  getDeviceAttributes,
+  getDeviceLimit,
+  getDevicesByStatus,
+  getDevicesWithAuth,
+  getDynamicGroups,
+  getGroups,
+  getIntegrations,
+  getReleases,
+  getUserOrganization,
+  tenantDataDivergedMessage
+} from '@northern.tech/store/thunks';
+import { act, renderHook } from '@testing-library/react';
+import configureMockStore from 'redux-mock-store';
+import { thunk } from 'redux-thunk';
+
+import { inventoryDevice } from '../../../tests/__mocks__/deviceHandlers';
+import { defaultState, receivedPermissionSets, receivedRoles, userId } from '../../../tests/mockData';
+import { actions as appActions } from './appSlice';
+import { getLatestReleaseInfo, setOfflineThreshold } from './appSlice/thunks';
+import { latestSaasReleaseTag } from './appSlice/thunks.test';
+import { getSessionInfo } from './auth';
+import { EXTERNAL_PROVIDER, TIMEOUTS, UNGROUPED_GROUP, timeUnits } from './commonConstants';
+import { DEVICE_STATES } from './constants';
+import { actions as deploymentsActions } from './deploymentsSlice';
+import { actions as deviceActions } from './devicesSlice';
+import { actions as onboardingActions } from './onboardingSlice';
+import { defaultOnboardingState, expectedOnboardingActions } from './onboardingSlice/thunks.test';
+import { actions as organizationActions } from './organizationSlice';
+import { actions as releasesActions } from './releasesSlice';
+import { useAppInit } from './storehooks';
+import { actions as userActions } from './usersSlice';
+import { getGlobalSettings, getPermissionSets, getRoles, getUserSettings, saveUserSettings } from './usersSlice/thunks';
+
+const middlewares = [thunk];
+const mockStore = configureMockStore(middlewares);
+
+const attributeReducer = (accu, item) => {
+  if (item.scope === 'inventory') {
+    accu[item.name] = item.value;
+    if (item.name === 'device_type') {
+      accu[item.name] = [].concat(item.value);
+    }
+  }
+  return accu;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const { attributes, ...expectedDevice } = defaultState.devices.byId.a1;
+export const receivedInventoryDevice = {
+  ...defaultState.devices.byId.a1,
+  attributes: inventoryDevice.attributes.reduce(attributeReducer, {}),
+  identity_data: { ...defaultState.devices.byId.a1.identity_data, status: DEVICE_STATES.accepted },
+  isNew: false,
+  isOffline: true,
+  monitor: {},
+  tags: {},
+  updated_ts: inventoryDevice.updated_ts
+};
+
+const appInitActions = [
+  { type: userActions.successfullyLoggedIn.type }, //, payload: { token }
+  { type: onboardingActions.setOnboardingComplete.type, payload: false },
+  { type: onboardingActions.setDemoArtifactPort.type, payload: 85 },
+  { type: appActions.setFeatures.type, payload: { ...defaultState.app.features, hasMultitenancy: true } },
+  {
+    type: appActions.setVersionInformation.type,
+    payload: {
+      docsVersion: '',
+      value: {
+        Deployments: '1.2.3',
+        Deviceauth: null,
+        GUI: undefined,
+        Integration: 'master',
+        Inventory: null,
+        'Mender-Artifact': undefined,
+        'Mender-Client': 'next',
+        'Meta-Mender': 'saas-123.34'
+      }
+    }
+  },
+  {
+    type: appActions.setEnvironmentData.type,
+    payload: { feedbackProbability: 0.3, hostAddress: null, hostedAnnouncement: '', recaptchaSiteKey: '', stripeAPIKey: '', trackerCode: '' }
+  },
+  { type: getLatestReleaseInfo.pending.type },
+  { type: getUserSettings.pending.type },
+  { type: getGlobalSettings.pending.type },
+  { type: getDeviceAttributes.pending.type },
+  { type: getDeploymentsByStatus.pending.type },
+  { type: getDeploymentsByStatus.pending.type },
+  { type: getDevicesByStatus.pending.type },
+  { type: getDevicesByStatus.pending.type },
+  { type: getDevicesByStatus.pending.type },
+  { type: getDevicesByStatus.pending.type },
+  { type: getDynamicGroups.pending.type },
+  { type: getGroups.pending.type },
+  { type: getIntegrations.pending.type },
+  { type: getReleases.pending.type },
+  { type: getDeviceLimit.pending.type },
+  { type: getRoles.pending.type },
+  { type: getPermissionSets.pending.type },
+  { type: appActions.setFirstLoginAfterSignup.type, payload: false },
+  { type: getUserOrganization.pending.type },
+  { type: deploymentsActions.receivedDeployments.type, payload: defaultState.deployments.byId },
+  {
+    type: deploymentsActions.receivedDeploymentsForStatus.type,
+    payload: { deploymentIds: Object.keys(defaultState.deployments.byId), status: 'finished', total: Object.keys(defaultState.deployments.byId).length }
+  },
+  { type: deploymentsActions.receivedDeployments.type, payload: defaultState.deployments.byId },
+  {
+    type: deploymentsActions.receivedDeploymentsForStatus.type,
+    payload: { deploymentIds: Object.keys(defaultState.deployments.byId), status: 'inprogress', total: Object.keys(defaultState.deployments.byId).length }
+  },
+  {
+    type: deploymentsActions.selectDeploymentsForStatus.type,
+    payload: { deploymentIds: Object.keys(defaultState.deployments.byId), status: 'inprogress', total: Object.keys(defaultState.deployments.byId).length }
+  },
+  { type: getDeploymentsByStatus.fulfilled.type },
+  { type: getDeploymentsByStatus.fulfilled.type },
+  { type: deviceActions.setDeviceLimit.type, payload: 500 },
+  { type: getDeviceLimit.fulfilled.type },
+  {
+    type: deviceActions.receivedGroups.type,
+    payload: {
+      testGroup: defaultState.devices.groups.byId.testGroup,
+      testGroupDynamic: { filters: [{ key: 'group', operator: '$eq', scope: 'system', value: 'things' }], id: 'filter1' }
+    }
+  },
+  { type: getDevicesByStatus.pending.type },
+  { type: deviceActions.setFilterAttributes.type },
+  { type: getDeviceAttributes.fulfilled.type },
+  {
+    type: deviceActions.receivedGroups.type,
+    payload: {
+      testGroup: defaultState.devices.groups.byId.testGroup,
+      testGroupDynamic: {
+        deviceIds: [],
+        filters: [
+          { key: 'id', operator: '$in', scope: 'identity', value: [defaultState.devices.byId.a1.id] },
+          { key: 'mac', operator: '$nexists', scope: 'identity', value: false },
+          { key: 'kernel', operator: '$exists', scope: 'identity', value: true }
+        ],
+        id: 'filter1',
+        total: 0
+      }
+    }
+  },
+  { type: getDynamicGroups.fulfilled.type },
+  {
+    type: deviceActions.receivedDevices.type,
+    payload: {
+      [defaultState.devices.byId.a1.id]: { ...receivedInventoryDevice, group: 'test' },
+      [defaultState.devices.byId.b1.id]: {
+        ...receivedInventoryDevice,
+        id: defaultState.devices.byId.b1.id,
+        group: 'test',
+        identity_data: { ...defaultState.devices.byId.b1.identity_data, status: DEVICE_STATES.accepted }
+      }
+    }
+  },
+  {
+    type: deviceActions.setDevicesByStatus.type,
+    payload: {
+      deviceIds: [defaultState.devices.byId.a1.id, defaultState.devices.byId.b1.id],
+      status: DEVICE_STATES.accepted,
+      total: defaultState.devices.byStatus.accepted.deviceIds.length
+    }
+  },
+  { type: getDevicesWithAuth.pending.type },
+  { type: deviceActions.receivedDevices.type, payload: { [expectedDevice.id]: { ...receivedInventoryDevice, group: 'test', status: 'pending' } } },
+  {
+    type: deviceActions.setDevicesByStatus.type,
+    payload: {
+      deviceIds: Array.from({ length: defaultState.devices.byStatus.pending.total }, () => defaultState.devices.byId.a1.id),
+      status: DEVICE_STATES.pending,
+      total: defaultState.devices.byStatus.pending.deviceIds.length
+    }
+  },
+  { type: getDevicesWithAuth.pending.type },
+  { type: deviceActions.receivedDevices.type, payload: {} },
+  { type: deviceActions.setDevicesByStatus.type, payload: { deviceIds: [], status: 'preauthorized', total: 0 } },
+  { type: deviceActions.receivedDevices.type, payload: {} },
+  { type: deviceActions.setDevicesByStatus.type, payload: { deviceIds: [], status: 'rejected', total: 0 } },
+  {
+    type: appActions.setVersionInformation.type,
+    payload: {
+      GUI: latestSaasReleaseTag,
+      Integration: '1.2.3',
+      'Mender-Artifact': '1.3.7',
+      'Mender-Client': '3.2.1',
+      backend: latestSaasReleaseTag,
+      latestRelease: {
+        releaseDate: '2022-02-02',
+        repos: {
+          integration: '1.2.3',
+          mender: '3.2.1',
+          'mender-artifact': '1.3.7',
+          'other-service': '1.1.0',
+          service: '3.0.0'
+        }
+      }
+    }
+  },
+  { type: organizationActions.setOrganization.type, payload: defaultState.organization.organization },
+  { type: appActions.setAnnouncement.type, payload: tenantDataDivergedMessage },
+  { type: getDevicesByStatus.fulfilled.type },
+  { type: getDevicesByStatus.fulfilled.type },
+  { type: getLatestReleaseInfo.fulfilled.type },
+  { type: getUserOrganization.fulfilled.type },
+  {
+    type: organizationActions.receiveExternalDeviceIntegrations.type,
+    payload: [
+      { connection_string: 'something_else', id: 1, provider: EXTERNAL_PROVIDER['iot-hub'].provider },
+      { id: 2, provider: EXTERNAL_PROVIDER['iot-core'].provider, something: 'new' }
+    ]
+  },
+  { type: getIntegrations.fulfilled.type },
+  { type: releasesActions.receiveReleases.type, payload: defaultState.releases.byId },
+  {
+    type: releasesActions.setReleaseListState.type,
+    payload: { ...defaultState.releases.releasesList, releaseIds: [defaultState.releases.byId.r1.name], page: 42 }
+  },
+  { type: getReleases.fulfilled.type },
+  {
+    type: deviceActions.receivedDevices.type,
+    payload: {
+      [expectedDevice.id]: { ...defaultState.devices.byId.a1, group: undefined, isNew: false, isOffline: true, monitor: {}, tags: {} },
+      [defaultState.devices.byId.b1.id]: { ...defaultState.devices.byId.b1, group: undefined, isNew: false, isOffline: true, monitor: {}, tags: {} }
+    }
+  },
+  {
+    type: deviceActions.receivedDevices.type,
+    payload: {
+      [expectedDevice.id]: { ...defaultState.devices.byId.a1, group: undefined, isNew: false, isOffline: true, monitor: {}, tags: {} }
+    }
+  },
+  { type: getDevicesWithAuth.fulfilled.type },
+  { type: getDevicesWithAuth.fulfilled.type },
+  {
+    type: deviceActions.receivedDevices.type,
+    payload: {
+      [expectedDevice.id]: { ...receivedInventoryDevice, group: 'test' },
+      [defaultState.devices.byId.b1.id]: { ...receivedInventoryDevice, id: defaultState.devices.byId.b1.id, group: 'test' }
+    }
+  },
+  { type: getDevicesWithAuth.pending.type },
+  { type: getDevicesByStatus.fulfilled.type },
+  { type: getDevicesByStatus.fulfilled.type },
+  { type: userActions.setGlobalSettings.type, payload: { ...defaultState.users.globalSettings } },
+  { type: setOfflineThreshold.pending.type },
+  { type: appActions.setOfflineThreshold.type, payload: '2019-01-12T13:00:06.900Z' },
+  { type: setOfflineThreshold.fulfilled.type },
+  { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+  { type: getGlobalSettings.fulfilled.type },
+  { type: getUserSettings.fulfilled.type },
+  { type: userActions.receivedPermissionSets.type, payload: receivedPermissionSets },
+  { type: getPermissionSets.fulfilled.type },
+  { type: userActions.receivedRoles.type, payload: receivedRoles },
+  { type: getRoles.fulfilled.type },
+  {
+    type: deviceActions.receivedDevices.type,
+    payload: {
+      [defaultState.devices.byId.a1.id]: { ...defaultState.devices.byId.a1, group: undefined, isNew: false, isOffline: true, monitor: {}, tags: {} },
+      [defaultState.devices.byId.b1.id]: { ...defaultState.devices.byId.b1, group: undefined, isNew: false, isOffline: true, monitor: {}, tags: {} }
+    }
+  },
+  { type: getDevicesWithAuth.fulfilled.type },
+  { type: getDevicesByStatus.fulfilled.type },
+  {
+    type: deviceActions.addGroup.type,
+    payload: {
+      groupName: UNGROUPED_GROUP.id,
+      group: {
+        filters: [{ key: 'group', operator: '$nin', scope: 'system', value: [Object.keys(defaultState.devices.groups.byId)[0]] }]
+      }
+    }
+  },
+  { type: getGroups.fulfilled.type },
+  { type: deviceActions.setDeviceListState.type, payload: { selectedAttributes: [] } },
+  { type: userActions.setTooltipsState.type, payload: {} },
+  { type: saveUserSettings.pending.type },
+  { type: getUserSettings.pending.type },
+  { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings } },
+  { type: getUserSettings.fulfilled.type },
+  { type: userActions.setUserSettings.type, payload: { ...defaultState.users.userSettings, onboarding: defaultOnboardingState } },
+  { type: saveUserSettings.fulfilled.type },
+  ...expectedOnboardingActions
+];
+
+it('should try to get all required app information', async () => {
+  const store = mockStore({
+    ...defaultState,
+    app: { ...defaultState.app, features: { ...defaultState.app.features, isHosted: true } },
+    users: {
+      ...defaultState.users,
+      currentSession: getSessionInfo(),
+      globalSettings: { ...defaultState.users.globalSettings, id_attribute: { attribute: 'mac', scope: 'identity' } }
+    },
+    releases: { ...defaultState.releases, releasesList: { ...defaultState.releases.releasesList, page: 42 } }
+  });
+  const wrapper = ({ children }) => <Provider store={store}>{children}</Provider>;
+  renderHook(() => useAppInit(userId), { wrapper });
+  await act(async () => {
+    jest.runAllTimers();
+    jest.runAllTicks();
+  });
+
+  const storeActions = store.getActions();
+  expect(storeActions.length).toEqual(appInitActions.length);
+  appInitActions.map((action, index) => Object.keys(action).map(key => expect(storeActions[index][key]).toEqual(action[key])));
+});
+it('should execute the offline threshold migration for multi day thresholds', async () => {
+  const store = mockStore({
+    ...defaultState,
+    app: { ...defaultState.app, features: { ...defaultState.app.features, isHosted: true } },
+    users: {
+      ...defaultState.users,
+      currentSession: getSessionInfo(),
+      globalSettings: {
+        ...defaultState.users.globalSettings,
+        id_attribute: { attribute: 'mac', scope: 'identity' },
+        offlineThreshold: { interval: 48, intervalUnit: timeUnits.hours }
+      }
+    },
+    releases: { ...defaultState.releases, releasesList: { ...defaultState.releases.releasesList, page: 42 } }
+  });
+  const wrapper = ({ children }) => <Provider store={store}>{children}</Provider>;
+  renderHook(() => useAppInit(userId), { wrapper });
+  await act(async () => {
+    jest.runAllTimers();
+    jest.runAllTicks();
+  });
+
+  const storeActions = store.getActions();
+  expect(storeActions.length).toEqual(appInitActions.length + 9); // 3 = get settings + set settings + set offline threshold
+  const settingStorageAction = storeActions.find(action => action.type === userActions.setGlobalSettings.type && action.payload.offlineThreshold);
+  expect(settingStorageAction.payload.offlineThreshold.interval).toEqual(2);
+  expect(settingStorageAction.payload.offlineThreshold.intervalUnit).toEqual(timeUnits.days);
+});
+it('should trigger the offline threshold migration dialog', async () => {
+  const store = mockStore({
+    ...defaultState,
+    app: { ...defaultState.app, features: { ...defaultState.app.features, isHosted: true } },
+    users: {
+      ...defaultState.users,
+      currentSession: getSessionInfo(),
+      globalSettings: {
+        ...defaultState.users.globalSettings,
+        id_attribute: { attribute: 'mac', scope: 'identity' },
+        offlineThreshold: { interval: 15, intervalUnit: 'minutes' }
+      }
+    },
+    releases: { ...defaultState.releases, releasesList: { ...defaultState.releases.releasesList, page: 42 } }
+  });
+
+  const wrapper = ({ children }) => <Provider store={store}>{children}</Provider>;
+  renderHook(() => useAppInit(userId), { wrapper });
+  await jest.advanceTimersByTimeAsync(TIMEOUTS.fiveSeconds + TIMEOUTS.oneSecond);
+  await jest.runAllTimersAsync();
+  await act(async () => {
+    jest.runAllTicks();
+  });
+  const storeActions = store.getActions();
+  expect(storeActions.length).toEqual(appInitActions.length + 1); // only setShowStartupNotification should be addded
+  const notificationAction = storeActions.find(action => action.type === userActions.setShowStartupNotification.type);
+  expect(notificationAction.payload).toBeTruthy();
+});

package/storehooks.ts

@@ -0,0 +1,250 @@
+// Copyright 2024 Northern.tech AS
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// @ts-nocheck
+import { useCallback, useEffect, useRef } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+
+import dayjs from 'dayjs';
+import durationDayJs from 'dayjs/plugin/duration';
+import Cookies from 'universal-cookie';
+
+import storeActions from './actions';
+import { getSessionInfo } from './auth';
+import { DEPLOYMENT_STATES, DEVICE_STATES, TIMEOUTS, timeUnits } from './constants';
+import {
+  getDevicesByStatus as getDevicesByStatusSelector,
+  getFeatures,
+  getGlobalSettings as getGlobalSettingsSelector,
+  getIsEnterprise,
+  getOfflineThresholdSettings,
+  getOnboardingState as getOnboardingStateSelector,
+  getSortedFilteringAttributes,
+  getUserCapabilities,
+  getUserSettings as getUserSettingsSelector
+} from './selectors';
+import {
+  getDeploymentsByStatus,
+  getDeviceAttributes,
+  getDeviceById,
+  getDeviceLimit,
+  getDevicesByStatus,
+  getDynamicGroups,
+  getGlobalSettings,
+  getGroups,
+  getIntegrations,
+  getLatestReleaseInfo,
+  getOnboardingState,
+  getReleases,
+  getRoles,
+  getUserOrganization,
+  getUserSettings,
+  saveGlobalSettings,
+  saveUserSettings
+} from './thunks';
+import { extractErrorMessage, getComparisonCompatibleVersion, stringToBoolean } from './utils';
+
+const cookies = new Cookies();
+dayjs.extend(durationDayJs);
+
+const { setDeviceListState, setFirstLoginAfterSignup, setTooltipsState, setShowStartupNotification } = storeActions;
+
+const featureFlags = [
+  'hasAuditlogs',
+  'hasMultitenancy',
+  'hasDeltaProgress',
+  'hasDeviceConfig',
+  'hasDeviceConnect',
+  'hasFeedbackEnabled',
+  'hasReporting',
+  'hasMonitor',
+  'isEnterprise'
+];
+
+const environmentDatas = ['feedbackProbability', 'hostAddress', 'hostedAnnouncement', 'recaptchaSiteKey', 'stripeAPIKey', 'trackerCode'];
+
+export const parseEnvironmentInfo = () => (dispatch, getState) => {
+  const state = getState();
+  let onboardingComplete = state.onboarding.complete || !!JSON.parse(window.localStorage.getItem('onboardingComplete') ?? 'false');
+  let demoArtifactPort = 85;
+  let environmentData = {};
+  let environmentFeatures = {};
+  let versionInfo = {};
+  if (mender_environment) {
+    const {
+      features = {},
+      demoArtifactPort: port,
+      disableOnboarding,
+      integrationVersion,
+      isDemoMode,
+      menderVersion,
+      menderArtifactVersion,
+      metaMenderVersion,
+      services = {}
+    } = mender_environment;
+    onboardingComplete = stringToBoolean(features.isEnterprise) || stringToBoolean(disableOnboarding) || onboardingComplete;
+    demoArtifactPort = port || demoArtifactPort;
+    environmentData = environmentDatas.reduce((accu, flag) => ({ ...accu, [flag]: mender_environment[flag] || state.app[flag] }), {});
+    environmentFeatures = {
+      ...featureFlags.reduce((accu, flag) => ({ ...accu, [flag]: stringToBoolean(features[flag]) }), {}),
+      isHosted: features.isHosted || window.location.hostname.includes('hosted.mender.io'),
+      isDemoMode: stringToBoolean(isDemoMode || features.isDemoMode)
+    };
+    versionInfo = {
+      docs: isNaN(integrationVersion.charAt(0)) ? '' : integrationVersion.split('.').slice(0, 2).join('.'),
+      remainder: {
+        Integration: getComparisonCompatibleVersion(integrationVersion),
+        'Mender-Client': getComparisonCompatibleVersion(menderVersion),
+        'Mender-Artifact': menderArtifactVersion,
+        'Meta-Mender': metaMenderVersion,
+        Deployments: services.deploymentsVersion,
+        Deviceauth: services.deviceauthVersion,
+        Inventory: services.inventoryVersion,
+        GUI: services.guiVersion
+      }
+    };
+  }
+  return Promise.all([
+    dispatch(storeActions.successfullyLoggedIn(getSessionInfo())),
+    dispatch(storeActions.setOnboardingComplete(onboardingComplete)),
+    dispatch(storeActions.setDemoArtifactPort(demoArtifactPort)),
+    dispatch(storeActions.setFeatures(environmentFeatures)),
+    dispatch(storeActions.setVersionInformation({ docsVersion: versionInfo.docs, value: versionInfo.remainder })),
+    dispatch(storeActions.setEnvironmentData(environmentData)),
+    dispatch(getLatestReleaseInfo())
+  ]);
+};
+
+const maybeAddOnboardingTasks = ({ devicesByStatus, dispatch, onboardingState, tasks }) => {
+  if (!onboardingState.showTips || onboardingState.complete) {
+    return tasks;
+  }
+  // try to retrieve full device details for onboarding devices to ensure ips etc. are available
+  // we only load the first few/ 20 devices, as it is possible the onboarding is left dangling
+  // and a lot of devices are present and we don't want to flood the backend for this
+  return devicesByStatus[DEVICE_STATES.accepted].deviceIds.reduce((accu, id) => {
+    accu.push(dispatch(getDeviceById(id)));
+    return accu;
+  }, tasks);
+};
+
+export const useAppInit = userId => {
+  const dispatch = useDispatch();
+  const isEnterprise = useSelector(getIsEnterprise);
+  const { hasMultitenancy, isHosted } = useSelector(getFeatures);
+  const devicesByStatus = useSelector(getDevicesByStatusSelector);
+  const onboardingState = useSelector(getOnboardingStateSelector);
+  let { columnSelection = [], trackingConsentGiven: hasTrackingEnabled, tooltips = {} } = useSelector(getUserSettingsSelector);
+  const { canManageUsers } = useSelector(getUserCapabilities);
+  const { interval, intervalUnit } = useSelector(getOfflineThresholdSettings);
+  const { id_attribute } = useSelector(getGlobalSettingsSelector);
+  const { identityAttributes } = useSelector(getSortedFilteringAttributes);
+  const initRunning = useRef(false);
+
+  const retrieveAppData = useCallback(() => {
+    let tasks = [
+      dispatch(parseEnvironmentInfo()),
+      dispatch(getUserSettings()),
+      dispatch(getGlobalSettings()),
+      dispatch(getDeviceAttributes()),
+      dispatch(getDeploymentsByStatus({ status: DEPLOYMENT_STATES.finished, shouldSelect: false })),
+      dispatch(getDeploymentsByStatus({ status: DEPLOYMENT_STATES.inprogress })),
+      dispatch(getDevicesByStatus({ status: DEVICE_STATES.accepted })),
+      dispatch(getDevicesByStatus({ status: DEVICE_STATES.pending })),
+      dispatch(getDevicesByStatus({ status: DEVICE_STATES.preauth })),
+      dispatch(getDevicesByStatus({ status: DEVICE_STATES.rejected })),
+      dispatch(getDynamicGroups()),
+      dispatch(getGroups()),
+      dispatch(getIntegrations()),
+      dispatch(getReleases()),
+      dispatch(getDeviceLimit()),
+      dispatch(getRoles()),
+      dispatch(setFirstLoginAfterSignup(stringToBoolean(cookies.get('firstLoginAfterSignup'))))
+    ];
+    const multitenancy = hasMultitenancy || isHosted || isEnterprise;
+    if (multitenancy) {
+      tasks.push(dispatch(getUserOrganization()));
+    }
+    return Promise.all(tasks);
+  }, [dispatch, hasMultitenancy, isHosted, isEnterprise]);
+
+  const interpretAppData = useCallback(() => {
+    let settings = {};
+    if (cookies.get('_ga') && typeof hasTrackingEnabled === 'undefined') {
+      settings.trackingConsentGiven = true;
+    }
+    let tasks = [
+      dispatch(setDeviceListState({ selectedAttributes: columnSelection.map(column => ({ attribute: column.key, scope: column.scope })) })),
+      dispatch(setTooltipsState(tooltips)), // tooltips read state is primarily trusted from the redux store, except on app init - here user settings are the reference
+      dispatch(saveUserSettings(settings))
+    ];
+    // checks if user id is set and if cookie for helptips exists for that user
+    tasks = maybeAddOnboardingTasks({ devicesByStatus, dispatch, tasks, onboardingState });
+
+    if (canManageUsers && intervalUnit && intervalUnit !== timeUnits.days) {
+      const duration = dayjs.duration(interval, intervalUnit);
+      const days = duration.asDays();
+      if (days < 1) {
+        tasks.push(Promise.resolve(setTimeout(() => dispatch(setShowStartupNotification(true)), TIMEOUTS.fiveSeconds)));
+      } else {
+        const roundedDays = Math.max(1, Math.round(days));
+        tasks.push(dispatch(saveGlobalSettings({ offlineThreshold: { interval: roundedDays, intervalUnit: timeUnits.days } })));
+      }
+    }
+
+    // the following is used as a migration and initialization of the stored identity attribute
+    // changing the default device attribute to the first non-deviceId attribute, unless a stored
+    // id attribute setting exists
+    const identityOptions = identityAttributes.filter(attribute => !['id', 'Device ID', 'status'].includes(attribute));
+    if (!id_attribute && identityOptions.length) {
+      tasks.push(dispatch(saveGlobalSettings({ id_attribute: { attribute: identityOptions[0], scope: 'identity' } })));
+    } else if (typeof id_attribute === 'string') {
+      let attribute = id_attribute;
+      if (attribute === 'Device ID') {
+        attribute = 'id';
+      }
+      tasks.push(dispatch(saveGlobalSettings({ id_attribute: { attribute, scope: 'identity' } })));
+    }
+    return Promise.all(tasks);
+  }, [
+    columnSelection,
+    dispatch,
+    identityAttributes,
+    hasTrackingEnabled,
+    canManageUsers,
+    devicesByStatus,
+    id_attribute,
+    interval,
+    intervalUnit,
+    onboardingState,
+    tooltips
+  ]);
+
+  const initializeAppData = useCallback(
+    () =>
+      retrieveAppData()
+        .then(interpretAppData)
+        // this is allowed to fail if no user information are available
+        .catch(err => console.log(extractErrorMessage(err)))
+        .then(() => dispatch(getOnboardingState())),
+    [dispatch, retrieveAppData, interpretAppData]
+  );
+
+  useEffect(() => {
+    if (!userId || initRunning.current) {
+      return;
+    }
+    initRunning.current = true;
+    initializeAppData();
+  }, [userId, initializeAppData]);
+};

package/thunks.ts

@@ -0,0 +1,21 @@
+// Copyright 2024 Northern.tech AS
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+export * from './appSlice/thunks';
+export * from './deploymentsSlice/thunks';
+export * from './devicesSlice/thunks';
+export * from './monitorSlice/thunks';
+export * from './onboardingSlice/thunks';
+export * from './organizationSlice/thunks';
+export * from './releasesSlice/thunks';
+export * from './usersSlice/thunks';

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "@northern.tech/typescript-config/react-app.json",
+  "exclude": ["dist", "build", "node_modules", "**/*.test.js"],
+  "compilerOptions": {
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {
+      "@northern.tech/store/*": ["*"]
+    }
+  }
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+import { peerDependencies } from './package.json';
+
+export default defineConfig(options => ({
+  format: ['cjs', 'esm'],
+  dts: true,
+  sourcemap: true,
+  external: [...Object.keys(peerDependencies)],
+  ...options
+}));