@gen-epix/ui 1.14.4 → 1.15.0

package/src/dataHooks/useCaseTypesQuery/useCaseTypesQuery.ts

@@ -0,0 +1,43 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { CaseType } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const caseTypesQueryFn = async ({ signal }: { signal: AbortSignal }): Promise<CaseType[]> => {
+  const response = await CaseApi.instance.caseTypesGetAll({ signal });
+  const items = response.data;
+  items.sort((a, b) => a.name.localeCompare(b.name));
+  return items;
+};
+
+export const useCaseTypesQuery = (): UseQueryResult<CaseType[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CASE_TYPES),
+    queryFn: caseTypesQueryFn,
+  });
+};
+
+export const useCaseTypeMapQuery = (): UseMap<CaseType> => {
+  const response = useCaseTypesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<CaseType>(response, item => item.id);
+  }, [response]);
+};
+
+export const useCaseTypeOptionsQuery = (): UseOptions<string> => {
+  const response = useCaseTypesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<CaseType>(response, item => item.id, item => item.name);
+  }, [response]);
+};

package/src/dataHooks/useColSetMembersQuery/index.ts

@@ -0,0 +1 @@
+export * from './useColSetMembersQuery';

package/src/dataHooks/useColSetMembersQuery/useColSetMembersQuery.ts

@@ -0,0 +1,17 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type { ColSetMember } from '../../api';
+import { CaseApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useColSetMembersQuery = (): UseQueryResult<ColSetMember[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.COL_SET_MEMBERS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.colSetMembersGetAll({ signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useColSetsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useColSetsQuery';

package/src/dataHooks/useColSetsQuery/useColSetsQuery.ts

@@ -0,0 +1,39 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { ColSet } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useColSetsQuery = (): UseQueryResult<ColSet[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.COL_SETS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.colSetsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useColSetMapQuery = (): UseMap<ColSet> => {
+  const response = useColSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<ColSet>(response, item => item.id);
+  }, [response]);
+};
+
+export const useColSetOptionsQuery = (): UseOptions<string> => {
+  const response = useColSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<ColSet>(response, item => item.id, item => item.name);
+  }, [response]);
+};

package/src/dataHooks/useColTypesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useColTypesQuery';

package/src/dataHooks/useColTypesQuery/useColTypesQuery.ts

@@ -0,0 +1,51 @@
+import { useMemo } from 'react';
+
+import { ColType } from '../../api';
+import type { UseOptions } from '../../models/dataHooks';
+import type { OptionBase } from '../../models/form';
+
+export const colTypePresentationValues: Record<ColType, string> = {
+  [ColType.TEXT]: 'TEXT',
+  [ColType.CONTEXT_FREE_GRAMMAR_JSON]: 'CONTEXT_FREE_GRAMMAR_JSON',
+  [ColType.CONTEXT_FREE_GRAMMAR_XML]: 'CONTEXT_FREE_GRAMMAR_XML',
+  [ColType.REGULAR_LANGUAGE]: 'REGULAR_LANGUAGE',
+  [ColType.NOMINAL]: 'NOMINAL',
+  [ColType.ORDINAL]: 'ORDINAL',
+  [ColType.INTERVAL]: 'INTERVAL',
+  [ColType.TIME_DAY]: 'TIME_DAY',
+  [ColType.TIME_WEEK]: 'TIME_WEEK',
+  [ColType.TIME_MONTH]: 'TIME_MONTH',
+  [ColType.TIME_QUARTER]: 'TIME_QUARTER',
+  [ColType.TIME_YEAR]: 'TIME_YEAR',
+  [ColType.GEO_LATLON]: 'GEO_LATLON',
+  [ColType.GEO_REGION]: 'GEO_REGION',
+  [ColType.ID_SAMPLE]: 'ID_SAMPLE',
+  [ColType.ID_CASE]: 'ID_CASE',
+  [ColType.ID_EVENT]: 'ID_EVENT',
+  [ColType.ID_GENETIC_SEQUENCE]: 'ID_GENETIC_SEQUENCE',
+  [ColType.ID_PERSON]: 'ID_PERSON',
+  [ColType.DECIMAL_0]: 'DECIMAL_0',
+  [ColType.DECIMAL_1]: 'DECIMAL_1',
+  [ColType.DECIMAL_2]: 'DECIMAL_2',
+  [ColType.DECIMAL_3]: 'DECIMAL_3',
+  [ColType.DECIMAL_4]: 'DECIMAL_4',
+  [ColType.DECIMAL_5]: 'DECIMAL_5',
+  [ColType.DECIMAL_6]: 'DECIMAL_6',
+  [ColType.GENETIC_SEQUENCE]: 'GENETIC_SEQUENCE',
+  [ColType.GENETIC_DISTANCE]: 'GENETIC_DISTANCE',
+  [ColType.ORGANIZATION]: 'ORGANIZATION',
+  [ColType.GENETIC_READS]: 'GENETIC_READS',
+  [ColType.GENETIC_PROFILE]: 'GENETIC_PROFILE',
+  [ColType.OTHER]: 'OTHER',
+};
+
+export const useColTypeOptionsQuery = (): UseOptions<string> => {
+  return useMemo(() => {
+    const options: OptionBase<string>[] = Object.entries(colTypePresentationValues).map(([value, label]) => ({ value, label }));
+    return {
+      isLoading: false,
+      options,
+      error: null,
+    } as UseOptions<string>;
+  }, []);
+};

package/src/dataHooks/useColsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useColsQuery';

package/src/dataHooks/useColsQuery/useColsQuery.ts

@@ -0,0 +1,60 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { Col } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseNameFactory,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useCaseTypeMapQuery } from '../useCaseTypesQuery';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+import { useDimMapQuery } from '../useDimsQuery';
+
+export const useColsQuery = (): UseQueryResult<Col[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.COLS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.colsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useColMapQuery = (): UseMap<Col> => {
+  const response = useColsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<Col>(response, item => item.id);
+  }, [response]);
+};
+
+export const useColNameFactory = (): UseNameFactory<Col> => {
+  const caseTypeMapQuery = useCaseTypeMapQuery();
+  const dimMapQuery = useDimMapQuery();
+
+  return useMemo(() => {
+    const getName = (item: Col) => {
+      const caseTypeName = caseTypeMapQuery.map.get(item.case_type_id)?.name ?? item.case_type_id;
+      const dimName = dimMapQuery.map.get(item.dim_id)?.label ?? item.dim_id;
+
+      return `${caseTypeName} → ${dimName} → ${item.label}`;
+
+    };
+    return DataHookUtil.createUseNameFactoryHook(getName, [caseTypeMapQuery, dimMapQuery]);
+  }, [dimMapQuery, caseTypeMapQuery]);
+};
+
+export const useColOptionsQuery = (): UseOptions<string> => {
+  const response = useColsQuery();
+
+  const colNameFactory = useColNameFactory();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<Col>(response, item => item.id, colNameFactory.getName, [colNameFactory]);
+  }, [colNameFactory, response]);
+};

package/src/dataHooks/useConceptQuery/index.ts

@@ -0,0 +1 @@
+export * from './useConceptQuery';

package/src/dataHooks/useConceptQuery/useConceptQuery.ts

@@ -0,0 +1,52 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { Concept } from '../../api';
+import { OntologyApi } from '../../api';
+import type {
+  UseMap,
+  UseNameFactory,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+import { useConceptSetMapQuery } from '../useConceptSetsQuery';
+
+export const useConceptQuery = (): UseQueryResult<Concept[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CONCEPTS),
+    queryFn: async ({ signal }) => {
+      const response = await OntologyApi.instance.conceptsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useConceptMapQuery = (): UseMap<Concept> => {
+  const response = useConceptQuery();
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<Concept>(response, item => item.id);
+  }, [response]);
+};
+
+export const useConceptNameFactory = (): UseNameFactory<Concept> => {
+  const conceptSetMapQuery = useConceptSetMapQuery();
+
+  return useMemo(() => {
+    const getName = (item: Concept) => {
+      return `${conceptSetMapQuery.map.get(item.concept_set_id)?.name ?? item.concept_set_id} → ${item.name}`;
+    };
+    return DataHookUtil.createUseNameFactoryHook(getName, [conceptSetMapQuery]);
+  }, [conceptSetMapQuery]);
+};
+
+export const useConceptOptionsQuery = (): UseOptions<string> => {
+  const conceptQuery = useConceptQuery();
+  const conceptNameFactory = useConceptNameFactory();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<Concept>(conceptQuery, item => item.id, conceptNameFactory.getName, [conceptNameFactory]);
+  }, [conceptNameFactory, conceptQuery]);
+};

package/src/dataHooks/useConceptRelationTypeQuery/index.ts

@@ -0,0 +1 @@
+export * from './useConceptRelationTypeQuery';

package/src/dataHooks/useConceptRelationTypeQuery/useConceptRelationTypeQuery.ts

@@ -0,0 +1,21 @@
+import { useMemo } from 'react';
+
+import { ConceptRelationType } from '../../api';
+import type { UseOptions } from '../../models/dataHooks';
+import type { OptionBase } from '../../models/form';
+
+
+export const conceptRelationTypePresentationValues: Partial<Record<ConceptRelationType, string>> = {
+  [ConceptRelationType.CONTAINS]: 'CONTAINS',
+};
+
+export const useConceptRelationTypeOptionsQuery = (): UseOptions<string> => {
+  return useMemo(() => {
+    const options: OptionBase<string>[] = Object.entries(conceptRelationTypePresentationValues).map(([value, label]) => ({ value, label }));
+    return {
+      isLoading: false,
+      options,
+      error: null,
+    } as UseOptions<string>;
+  }, []);
+};

package/src/dataHooks/useConceptSetTypeQuery/index.ts

@@ -0,0 +1 @@
+export * from './useConceptSetTypeQuery';

package/src/dataHooks/useConceptSetTypeQuery/useConceptSetTypeQuery.ts

@@ -0,0 +1,27 @@
+import { useMemo } from 'react';
+
+import type { UseOptions } from '../../models/dataHooks';
+import type { OptionBase } from '../../models/form';
+import { ConceptSetType } from '../../api';
+
+
+export const conceptSetTypePresentationValues: Partial<Record<ConceptSetType, string>> = {
+  [ConceptSetType.CONTEXT_FREE_GRAMMAR_JSON]: 'CONTEXT_FREE_GRAMMAR_JSON',
+  [ConceptSetType.CONTEXT_FREE_GRAMMAR_XML]: 'CONTEXT_FREE_GRAMMAR_XML',
+  [ConceptSetType.REGULAR_LANGUAGE]: 'REGULAR_LANGUAGE',
+  [ConceptSetType.NOMINAL]: 'NOMINAL',
+  [ConceptSetType.ORDINAL]: 'ORDINAL',
+  [ConceptSetType.INTERVAL]: 'INTERVAL',
+
+};
+
+export const useConceptSetTypeOptionsQuery = (): UseOptions<string> => {
+  return useMemo(() => {
+    const options: OptionBase<string>[] = Object.entries(conceptSetTypePresentationValues).map(([value, label]) => ({ value, label }));
+    return {
+      isLoading: false,
+      options,
+      error: null,
+    } as UseOptions<string>;
+  }, []);
+};

package/src/dataHooks/useConceptSetsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useConceptSetsQuery';

package/src/dataHooks/useConceptSetsQuery/useConceptSetsQuery.ts

@@ -0,0 +1,38 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { ConceptSet } from '../../api';
+import { OntologyApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useConceptSetsQuery = (): UseQueryResult<ConceptSet[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.CONCEPT_SETS),
+    queryFn: async ({ signal }) => {
+      const response = await OntologyApi.instance.conceptSetsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useConceptSetMapQuery = (): UseMap<ConceptSet> => {
+  const response = useConceptSetsQuery();
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<ConceptSet>(response, item => item.id);
+  }, [response]);
+};
+
+export const useConceptSetOptionsQuery = (): UseOptions<string> => {
+  const conceptSetsQuery = useConceptSetsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<ConceptSet>(conceptSetsQuery, item => item.id, item => item.name);
+  }, [conceptSetsQuery]);
+};

package/src/dataHooks/useDataCollectionSetMembersQuery/index.ts

@@ -0,0 +1 @@
+export * from './useDataCollectionSetMembersQuery';

package/src/dataHooks/useDataCollectionSetMembersQuery/useDataCollectionSetMembersQuery.ts

@@ -0,0 +1,17 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+
+import type { DataCollectionSetMember } from '../../api';
+import { OrganizationApi } from '../../api';
+import { QUERY_KEY } from '../../models/query';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useDataCollectionSetMembersQuery = (): UseQueryResult<DataCollectionSetMember[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.DATA_COLLECTION_SET_MEMBERS),
+    queryFn: async ({ signal }) => {
+      const response = await OrganizationApi.instance.dataCollectionSetMembersGetAll({ signal });
+      return response.data;
+    },
+  });
+};

package/src/dataHooks/useDataCollectionsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useDataCollectionsQuery';

package/src/dataHooks/useDataCollectionsQuery/useDataCollectionsQuery.ts

@@ -0,0 +1,45 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { DataCollection } from '../../api';
+import { OrganizationApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useDataCollectionsQuery = (dataCollectionIds?: string[]): UseQueryResult<DataCollection[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.DATA_COLLECTIONS),
+    queryFn: async ({ signal }) => {
+      const response = await OrganizationApi.instance.dataCollectionsGetAll({ signal });
+      return response.data;
+    },
+    select: (items) => {
+      if (dataCollectionIds) {
+        return items.filter(item => dataCollectionIds.includes(item.id));
+      }
+      return items;
+    },
+  });
+};
+
+export const useDataCollectionsMapQuery = (dataCollectionIds?: string[]): UseMap<DataCollection> => {
+  const dataCollectionsQuery = useDataCollectionsQuery(dataCollectionIds);
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<DataCollection>(dataCollectionsQuery, item => item.id);
+  }, [dataCollectionsQuery]);
+};
+
+export const useDataCollectionOptionsQuery = (dataCollectionIds?: string[]): UseOptions<string> => {
+  const dataCollectionsQuery = useDataCollectionsQuery(dataCollectionIds);
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<DataCollection>(dataCollectionsQuery, item => item.id, item => item.name);
+  }, [dataCollectionsQuery]);
+};

package/src/dataHooks/useDimTypesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useDimTypesQuery';

package/src/dataHooks/useDimTypesQuery/useDimTypesQuery.ts

@@ -0,0 +1,26 @@
+import { useMemo } from 'react';
+
+import { DimType } from '../../api';
+import type { UseOptions } from '../../models/dataHooks';
+import type { OptionBase } from '../../models/form';
+
+export const dimTypePresentationValues: Record<DimType, string> = {
+  [DimType.GEO]: 'GEO',
+  [DimType.IDENTIFIER]: 'IDENTIFIER',
+  [DimType.NUMBER]: 'NUMBER',
+  [DimType.ORGANIZATION]: 'ORGANIZATION',
+  [DimType.OTHER]: 'OTHER',
+  [DimType.TEXT]: 'TEXT',
+  [DimType.TIME]: 'TIME',
+};
+
+export const useDimTypeOptionsQuery = (): UseOptions<string> => {
+  return useMemo(() => {
+    const options: OptionBase<string>[] = Object.entries(dimTypePresentationValues).map(([value, label]) => ({ value, label }));
+    return {
+      isLoading: false,
+      options,
+      error: null as UseOptions<string>,
+    };
+  }, []);
+};

package/src/dataHooks/useDimsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useDimsQuery';

package/src/dataHooks/useDimsQuery/useDimsQuery.ts

@@ -0,0 +1,55 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { Dim } from '../../api';
+import { CaseApi } from '../../api';
+import type {
+  UseMap,
+  UseNameFactory,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+import { useCaseTypeMapQuery } from '../useCaseTypesQuery';
+
+export const useDimsQuery = (): UseQueryResult<Dim[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.DIMS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.dimsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useDimMapQuery = (): UseMap<Dim> => {
+  const response = useDimsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<Dim>(response, item => item.id);
+  }, [response]);
+};
+
+export const useDimNameFactory = (): UseNameFactory<Dim> => {
+  const caseTypeMapQuery = useCaseTypeMapQuery();
+
+  return useMemo(() => {
+    const getName = (item: Dim) => {
+      const caseTypeName = caseTypeMapQuery.map.get(item.case_type_id)?.name ?? item.case_type_id;
+      return `${caseTypeName} → ${item.label}`;
+    };
+    return DataHookUtil.createUseNameFactoryHook(getName, [caseTypeMapQuery]);
+  }, [caseTypeMapQuery]);
+};
+
+export const useDimOptionsQuery = (): UseOptions<string> => {
+  const response = useDimsQuery();
+
+  const dimNameFactory = useDimNameFactory();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<Dim>(response, item => item.id, dimNameFactory.getName, [dimNameFactory]);
+  }, [dimNameFactory, response]);
+};

package/src/dataHooks/useDiseasesQuery/index.ts

@@ -0,0 +1 @@
+export * from './useDiseasesQuery';

package/src/dataHooks/useDiseasesQuery/useDiseasesQuery.ts

@@ -0,0 +1,39 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { Disease } from '../../api';
+import { OntologyApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useDiseasesQuery = (): UseQueryResult<Disease[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.DISEASES),
+    queryFn: async ({ signal }) => {
+      const response = await OntologyApi.instance.diseasesGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useDiseasesMapQuery = (): UseMap<Disease> => {
+  const diseasesQuery = useDiseasesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<Disease>(diseasesQuery, item => item.id);
+  }, [diseasesQuery]);
+};
+
+export const useDiseaseOptionsQuery = (): UseOptions<string> => {
+  const diseasesQuery = useDiseasesQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<Disease>(diseasesQuery, item => item.id, item => item.name);
+  }, [diseasesQuery]);
+};

package/src/dataHooks/useEtiologicalAgentsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useEtiologicalAgentsQuery';

package/src/dataHooks/useEtiologicalAgentsQuery/useEtiologicalAgentsQuery.ts

@@ -0,0 +1,39 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { EtiologicalAgent } from '../../api';
+import { OntologyApi } from '../../api';
+import type {
+  UseMap,
+  UseOptions,
+} from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useEtiologicalAgentsQuery = (): UseQueryResult<EtiologicalAgent[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.ETIOLOGICAL_AGENTS),
+    queryFn: async ({ signal }) => {
+      const response = await OntologyApi.instance.etiologicalAgentsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useEtiologicalAgentsMapQuery = (): UseMap<EtiologicalAgent> => {
+  const etiologicalAgentsQuery = useEtiologicalAgentsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseMapDataHook<EtiologicalAgent>(etiologicalAgentsQuery, item => item.id);
+  }, [etiologicalAgentsQuery]);
+};
+
+export const useEtiologicalAgentOptionsQuery = (): UseOptions<string> => {
+  const etiologicalAgentsQuery = useEtiologicalAgentsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<EtiologicalAgent>(etiologicalAgentsQuery, item => item.id, item => item.name);
+  }, [etiologicalAgentsQuery]);
+};

package/src/dataHooks/useGeneticDistanceProtocolsQuery/index.ts

@@ -0,0 +1 @@
+export * from './useGeneticDistanceProtocolsQuery';

package/src/dataHooks/useGeneticDistanceProtocolsQuery/useGeneticDistanceProtocolsQuery.ts

@@ -0,0 +1,29 @@
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+import type { GeneticDistanceProtocol } from '../../api';
+import { CaseApi } from '../../api';
+import type { UseOptions } from '../../models/dataHooks';
+import { QUERY_KEY } from '../../models/query';
+import { DataHookUtil } from '../../utils/DataHookUtil';
+import { QueryUtil } from '../../utils/QueryUtil';
+import { useQueryMemo } from '../../hooks/useQueryMemo';
+
+export const useGeneticDistanceProtocolsQuery = (): UseQueryResult<GeneticDistanceProtocol[]> => {
+  return useQueryMemo({
+    queryKey: QueryUtil.getGenericKey(QUERY_KEY.GENETIC_DISTANCE_PROTOCOLS),
+    queryFn: async ({ signal }) => {
+      const response = await CaseApi.instance.geneticDistanceProtocolsGetAll({ signal });
+      return response.data;
+    },
+  });
+};
+
+export const useGeneticDistanceProtocolOptionsQuery = (): UseOptions<string> => {
+  const geneticDistanceProtocolsQuery = useGeneticDistanceProtocolsQuery();
+
+  return useMemo(() => {
+    return DataHookUtil.createUseOptionsDataHook<GeneticDistanceProtocol>(geneticDistanceProtocolsQuery, item => item.id, item => item.name);
+
+  }, [geneticDistanceProtocolsQuery]);
+};