16975232731

Committed 14 Aug 2025 07:53PM UTC coverage: 75.695% (-0.008%) from 75.703%

Build # 16975232731

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #822 from CBIIT/CRDCDH-2995-V2

CRDCDH-2995 Show non-caDSR Origins

Run Details

4117 of 4562 branches covered (90.25%)

Branch coverage included in aggregate %.

9 of 17 new or added lines in 2 files covered. (52.94%)

1 existing line in 1 file now uncovered.

25629 of 34735 relevant lines covered (73.78%)

163.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/hooks/useBuildReduxStore.ts

import { useLazyQuery } from "@apollo/client";
import {
  ddgraph,
  moduleReducers as submission,
  versionInfo,
  changelogInfo,
  iconMapInfo,
  getModelExploreData,
  getChangelog,
} from "data-model-navigator";
import { useState } from "react";
import { createStore, combineReducers, Store } from "redux";

import logo from "../assets/header/Logo.jpg";
import { baseConfiguration, defaultReadMeTitle, graphViewConfig } from "../config/ModelNavigator";
import { RETRIEVE_CDEs, RetrieveCDEsInput, RetrieveCDEsResp } from "../graphql";
import {
  buildAssetUrls,
  buildBaseFilterContainers,
  buildFilterOptionsList,
  Logger,
  extractSupportedCDEs,
  populateCDEData,
} from "../utils";

export type ReduxStoreStatus = "waiting" | "loading" | "error" | "success";

export type ReduxStoreData = {
  /**
   * The current status of the Redux store.
   */
  status: ReduxStoreStatus;
  /**
   * The Redux store instance.
   */
  store: Store;
};

export type ReduxStoreResult = [ReduxStoreData, (assets: DataCommon, modelVersion: string) => void];

const makeStore = (): Store => {
  const reducers = { ddgraph, versionInfo, submission, changelogInfo, iconMapInfo };
  const newStore = createStore(combineReducers(reducers));

  // @ts-ignore
  newStore.injectReducer = (key, reducer) => {
    reducers[key] = reducer;
    newStore.replaceReducer(combineReducers(reducers));
  };

  return newStore;
};

/**
 * A hook to build and populate the Redux store with DMN data
 *
 * @params {void}
 */
const useBuildReduxStore = (): ReduxStoreResult => {
  const [store] = useState<Store>(makeStore());
  const [status, setStatus] = useState<ReduxStoreStatus>("waiting");

  const [retrieveCDEs] = useLazyQuery<RetrieveCDEsResp, RetrieveCDEsInput>(RETRIEVE_CDEs, {
    context: { clientName: "backend" },
    fetchPolicy: "cache-first",
  });

  /**
   * Injects the Data Model into the store
   *
   * @param datacommon The Data Model to inject assets from
   * @param modelVersion The version of the Data Model to inject
   */
  const populateStore = async (datacommon: DataCommon, modelVersion: string) => {
    if (
      !datacommon?.name ||
      !datacommon?.assets ||
      !datacommon?.assets["current-version"] ||
      !datacommon?.assets["model-navigator-config"]
    ) {
      setStatus("error");
      return;
    }

    setStatus("loading");

    const assets = buildAssetUrls(datacommon, modelVersion);
    const dmnConfig = datacommon.assets["model-navigator-config"];

    const changelogMD = await getChangelog(assets?.changelog)?.catch((e) => {
      Logger.error(e);
      return null;
    });

    const { data: dictionary, version } =
      (await getModelExploreData(...assets.model_files)?.catch((e) => {
        Logger.error(e);
        return {};
      })) || {};

    if (!dictionary || !version) {
      setStatus("error");
      return;
    }

    const allCDEs = extractSupportedCDEs(dictionary);
    if (allCDEs.length > 0) {
      try {
        const CDEs = await retrieveCDEs({
          variables: {
            cdeInfo: allCDEs.map(({ CDECode, CDEVersion }) => ({ CDECode, CDEVersion })),
          },
        });
        populateCDEData(dictionary, CDEs?.data?.retrieveCDEs || []);
      } catch (error) {
        populateCDEData(dictionary, []);
      }
    }

    store.dispatch({ type: "RECEIVE_VERSION_INFO", data: version });

    store.dispatch({
      type: "REACT_FLOW_GRAPH_DICTIONARY",
      dictionary,
      pdfDownloadConfig: {
        iconSrc: logo,
        ...dmnConfig.pdfConfig,
      },
      graphViewConfig,
    });

    store.dispatch({
      type: "RECEIVE_DICTIONARY",
      payload: {
        data: dictionary,
        facetfilterConfig: {
          ...baseConfiguration,
          facetSearchData: dmnConfig.facetFilterSearchData,
          facetSectionVariables: dmnConfig.facetFilterSectionVariables,
          baseFilters: buildBaseFilterContainers(dmnConfig),
          filterSections: dmnConfig.facetFilterSearchData.map((s) => s?.datafield),
          filterOptions: buildFilterOptionsList(dmnConfig),
        },
        pageConfig: {
          title: dmnConfig.pageTitle,
          iconSrc: assets.navigator_icon,
        },
        readMeConfig: {
          readMeUrl: assets.readme,
          readMeTitle: dmnConfig?.readMeTitle || defaultReadMeTitle,
          allowDownload: false,
        },
        pdfDownloadConfig: dmnConfig.pdfConfig,
        loadingExampleConfig: {
          type: "static",
          url: assets.loading_file,
        },
      },
    });

    store.dispatch({
      type: "RECEIVE_CHANGELOG_INFO",
      data: {
        changelogMD,
        changelogTabName: "Version History",
      },
    });

    if (datacommon?.assets?.["model-navigator-config"]?.iconMap) {
      store.dispatch({
        type: "RECEIVE_ICON_MAP",
        data: datacommon?.assets?.["model-navigator-config"]?.iconMap,
      });
    }

    // MVP-2 M2 NOTE: This resets the search history to prevent the data models
    // from overlapping on searches. A future improvement would be to isolate
    // the localStorage history key to the data model based on a config option.
    store.dispatch({ type: "SEARCH_CLEAR_HISTORY" });

    setStatus("success");
  };

  return [{ status, store }, populateStore];
};

export default useBuildReduxStore;

1	import { useLazyQuery } from "@apollo/client";	×
2	import {	×
3	ddgraph,
4	moduleReducers as submission,
5	versionInfo,
6	changelogInfo,
7	iconMapInfo,
8	getModelExploreData,
9	getChangelog,
10	} from "data-model-navigator";
11	import { useState } from "react";	×
12	import { createStore, combineReducers, Store } from "redux";	×
13
14	import logo from "../assets/header/Logo.jpg";	×
15	import { baseConfiguration, defaultReadMeTitle, graphViewConfig } from "../config/ModelNavigator";	×
16	import { RETRIEVE_CDEs, RetrieveCDEsInput, RetrieveCDEsResp } from "../graphql";	×
17	import {	×
18	buildAssetUrls,
19	buildBaseFilterContainers,
20	buildFilterOptionsList,
21	Logger,
22	extractSupportedCDEs,
23	populateCDEData,
24	} from "../utils";
25
26	export type ReduxStoreStatus = "waiting" \| "loading" \| "error" \| "success";
27
28	export type ReduxStoreData = {
29	/**
30	* The current status of the Redux store.
31	*/
32	status: ReduxStoreStatus;
33	/**
34	* The Redux store instance.
35	*/
36	store: Store;
37	};
38
39	export type ReduxStoreResult = [ReduxStoreData, (assets: DataCommon, modelVersion: string) => void];
40
41	const makeStore = (): Store => {	×
42	const reducers = { ddgraph, versionInfo, submission, changelogInfo, iconMapInfo };	×
43	const newStore = createStore(combineReducers(reducers));	×
44
45	// @ts-ignore
46	newStore.injectReducer = (key, reducer) => {	×
47	reducers[key] = reducer;	×
48	newStore.replaceReducer(combineReducers(reducers));	×
49	};	×
50
51	return newStore;	×
52	};	×
53
54	/**
55	* A hook to build and populate the Redux store with DMN data
56	*
57	* @params {void}
58	*/
59	const useBuildReduxStore = (): ReduxStoreResult => {	×
60	const [store] = useState<Store>(makeStore());	×
61	const [status, setStatus] = useState<ReduxStoreStatus>("waiting");	×
62
63	const [retrieveCDEs] = useLazyQuery<RetrieveCDEsResp, RetrieveCDEsInput>(RETRIEVE_CDEs, {	×
64	context: { clientName: "backend" },	×
65	fetchPolicy: "cache-first",	×
66	});	×
67
68	/**
69	* Injects the Data Model into the store
70	*
71	* @param datacommon The Data Model to inject assets from
72	* @param modelVersion The version of the Data Model to inject
73	*/
74	const populateStore = async (datacommon: DataCommon, modelVersion: string) => {	×
75	if (	×
76	!datacommon?.name \|\|	×
77	!datacommon?.assets \|\|	×
78	!datacommon?.assets["current-version"] \|\|	×
79	!datacommon?.assets["model-navigator-config"]	×
80	) {	×
81	setStatus("error");	×
82	return;	×
83	}	×
84
85	setStatus("loading");	×
86
87	const assets = buildAssetUrls(datacommon, modelVersion);	×
88	const dmnConfig = datacommon.assets["model-navigator-config"];	×
89
90	const changelogMD = await getChangelog(assets?.changelog)?.catch((e) => {	×
91	Logger.error(e);	×
92	return null;	×
93	});	×
94
NEW 95	const { data: dictionary, version } =	×
NEW 96	(await getModelExploreData(...assets.model_files)?.catch((e) => {	×
NEW 97	Logger.error(e);	×
NEW 98	return {};	×
NEW 99	})) \|\| {};	×
100
NEW 101	if (!dictionary \|\| !version) {	×
102	setStatus("error");	×
103	return;	×
104	}	×
105
NEW 106	const allCDEs = extractSupportedCDEs(dictionary);	×
UNCOV 107	if (allCDEs.length > 0) {	×
108	try {	×
109	const CDEs = await retrieveCDEs({	×
110	variables: {	×
111	cdeInfo: allCDEs.map(({ CDECode, CDEVersion }) => ({ CDECode, CDEVersion })),	×
112	},	×
113	});	×
114	populateCDEData(dictionary, CDEs?.data?.retrieveCDEs \|\| []);	×
115	} catch (error) {	×
116	populateCDEData(dictionary, []);	×
117	}	×
118	}	×
119
NEW 120	store.dispatch({ type: "RECEIVE_VERSION_INFO", data: version });	×
121
122	store.dispatch({	×
123	type: "REACT_FLOW_GRAPH_DICTIONARY",	×
124	dictionary,	×
125	pdfDownloadConfig: {	×
126	iconSrc: logo,	×
127	...dmnConfig.pdfConfig,	×
128	},	×
129	graphViewConfig,	×
130	});	×
131
132	store.dispatch({	×
133	type: "RECEIVE_DICTIONARY",	×
134	payload: {	×
135	data: dictionary,	×
136	facetfilterConfig: {	×
137	...baseConfiguration,	×
138	facetSearchData: dmnConfig.facetFilterSearchData,	×
139	facetSectionVariables: dmnConfig.facetFilterSectionVariables,	×
140	baseFilters: buildBaseFilterContainers(dmnConfig),	×
141	filterSections: dmnConfig.facetFilterSearchData.map((s) => s?.datafield),	×
142	filterOptions: buildFilterOptionsList(dmnConfig),	×
143	},	×
144	pageConfig: {	×
145	title: dmnConfig.pageTitle,	×
146	iconSrc: assets.navigator_icon,	×
147	},	×
148	readMeConfig: {	×
149	readMeUrl: assets.readme,	×
150	readMeTitle: dmnConfig?.readMeTitle \|\| defaultReadMeTitle,	×
151	allowDownload: false,	×
152	},	×
153	pdfDownloadConfig: dmnConfig.pdfConfig,	×
154	loadingExampleConfig: {	×
155	type: "static",	×
156	url: assets.loading_file,	×
157	},	×
158	},	×
159	});	×
160
161	store.dispatch({	×
162	type: "RECEIVE_CHANGELOG_INFO",	×
163	data: {	×
164	changelogMD,	×
165	changelogTabName: "Version History",	×
166	},	×
167	});	×
168
169	if (datacommon?.assets?.["model-navigator-config"]?.iconMap) {	×
170	store.dispatch({	×
171	type: "RECEIVE_ICON_MAP",	×
172	data: datacommon?.assets?.["model-navigator-config"]?.iconMap,	×
173	});	×
174	}	×
175
176	// MVP-2 M2 NOTE: This resets the search history to prevent the data models
177	// from overlapping on searches. A future improvement would be to isolate
178	// the localStorage history key to the data model based on a config option.
179	store.dispatch({ type: "SEARCH_CLEAR_HISTORY" });	×
180
181	setStatus("success");	×
182	};	×
183
184	return [{ status, store }, populateStore];	×
185	};	×
186
187	export default useBuildReduxStore;	×

CBIIT / crdc-datahub-ui / 16975232731

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous