feat: Merge Data Source (#3788)

Add the ability to merge two different series queries to generate a complete study query result.  Provides basic support for other types of merges, but those aren't yet added as full features.

extensions/default/src/MergeDataSource/index.test.js

@@ -0,0 +1,203 @@
+import { DicomMetadataStore, IWebApiDataSource } from '@ohif/core';
+import {
+  mergeMap,
+  callForAllDataSourcesAsync,
+  callForAllDataSources,
+  callForDefaultDataSource,
+  callByRetrieveAETitle,
+  createMergeDataSourceApi,
+} from './index';
+
+jest.mock('@ohif/core');
+
+describe('MergeDataSource', () => {
+  let path,
+    sourceName,
+    mergeConfig,
+    extensionManager,
+    series1,
+    series2,
+    series3,
+    series4,
+    mergeKey,
+    tagFunc,
+    dataSourceAndSeriesMap,
+    dataSourceAndUIDsMap,
+    dataSourceAndDSMap,
+    pathSync;
+
+  beforeAll(() => {
+    path = 'query.series.search';
+    pathSync = 'getImageIdsForInstance';
+    tagFunc = jest.fn((data, sourceName) =>
+      data.map(item => ({ ...item, RetrieveAETitle: sourceName }))
+    );
+    sourceName = 'dicomweb1';
+    mergeKey = 'seriesInstanceUid';
+    series1 = { [mergeKey]: '123' };
+    series2 = { [mergeKey]: '234' };
+    series3 = { [mergeKey]: '345' };
+    series4 = { [mergeKey]: '456' };
+    mergeConfig = {
+      seriesMerge: {
+        dataSourceNames: ['dicomweb1', 'dicomweb2'],
+        defaultDataSourceName: 'dicomweb1',
+      },
+    };
+    dataSourceAndSeriesMap = {
+      dataSource1: series1,
+      dataSource2: series2,
+      dataSource3: series3,
+    };
+    dataSourceAndUIDsMap = {
+      dataSource1: ['123'],
+      dataSource2: ['234'],
+      dataSource3: ['345'],
+    };
+    dataSourceAndDSMap = {
+      dataSource1: {
+        displaySet: {
+          StudyInstanceUID: '123',
+          SeriesInstanceUID: '123',
+        },
+      },
+      dataSource2: {
+        displaySet: {
+          StudyInstanceUID: '234',
+          SeriesInstanceUID: '234',
+        },
+      },
+      dataSource3: {
+        displaySet: {
+          StudyInstanceUID: '345',
+          SeriesInstanceUID: '345',
+        },
+      },
+    };
+    extensionManager = {
+      dataSourceDefs: {
+        dataSource1: {
+          sourceName: 'dataSource1',
+          configuration: {},
+        },
+        dataSource2: {
+          sourceName: 'dataSource2',
+          configuration: {},
+        },
+        dataSource3: {
+          sourceName: 'dataSource3',
+          configuration: {},
+        },
+      },
+      getDataSources: jest.fn(dataSourceName => [
+        {
+          [path]: jest.fn().mockResolvedValue([dataSourceAndSeriesMap[dataSourceName]]),
+        },
+      ]),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('callForAllDataSourcesAsync', () => {
+    it('should call the correct functions and return the merged data', async () => {
+      /** Arrange */
+      extensionManager.getDataSources = jest.fn(dataSourceName => [
+        {
+          [path]: jest.fn().mockResolvedValue([dataSourceAndSeriesMap[dataSourceName]]),
+        },
+      ]);
+
+      /** Act */
+      const data = await callForAllDataSourcesAsync({
+        mergeMap,
+        path,
+        args: [],
+        extensionManager,
+        dataSourceNames: ['dataSource1', 'dataSource2'],
+      });
+
+      /** Assert */
+      expect(extensionManager.getDataSources).toHaveBeenCalledTimes(2);
+      expect(extensionManager.getDataSources).toHaveBeenCalledWith('dataSource1');
+      expect(extensionManager.getDataSources).toHaveBeenCalledWith('dataSource2');
+      expect(data).toEqual([series1, series2]);
+    });
+  });
+
+  describe('callForAllDataSources', () => {
+    it('should call the correct functions and return the merged data', () => {
+      /** Arrange */
+      extensionManager.getDataSources = jest.fn(dataSourceName => [
+        {
+          [pathSync]: () => dataSourceAndUIDsMap[dataSourceName],
+        },
+      ]);
+
+      /** Act */
+      const data = callForAllDataSources({
+        path: pathSync,
+        args: [],
+        extensionManager,
+        dataSourceNames: ['dataSource2', 'dataSource3'],
+      });
+
+      /** Assert */
+      expect(extensionManager.getDataSources).toHaveBeenCalledTimes(2);
+      expect(extensionManager.getDataSources).toHaveBeenCalledWith('dataSource2');
+      expect(extensionManager.getDataSources).toHaveBeenCalledWith('dataSource3');
+      expect(data).toEqual(['234', '345']);
+    });
+  });
+
+  describe('callForDefaultDataSource', () => {
+    it('should call the correct function and return the data', () => {
+      /** Arrange */
+      extensionManager.getDataSources = jest.fn(dataSourceName => [
+        {
+          [pathSync]: () => dataSourceAndUIDsMap[dataSourceName],
+        },
+      ]);
+
+      /** Act */
+      const data = callForDefaultDataSource({
+        path: pathSync,
+        args: [],
+        extensionManager,
+        defaultDataSourceName: 'dataSource2',
+      });
+
+      /** Assert */
+      expect(extensionManager.getDataSources).toHaveBeenCalledTimes(1);
+      expect(extensionManager.getDataSources).toHaveBeenCalledWith('dataSource2');
+      expect(data).toEqual(['234']);
+    });
+  });
+
+  describe('callByRetrieveAETitle', () => {
+    it('should call the correct function and return the data', () => {
+      /** Arrange */
+      DicomMetadataStore.getSeries.mockImplementationOnce(() => [series2]);
+      extensionManager.getDataSources = jest.fn(dataSourceName => [
+        {
+          [pathSync]: () => dataSourceAndUIDsMap[dataSourceName],
+        },
+      ]);
+
+      /** Act */
+      const data = callByRetrieveAETitle({
+        path: pathSync,
+        args: [dataSourceAndDSMap['dataSource2']],
+        extensionManager,
+        defaultDataSourceName: 'dataSource2',
+      });
+
+      /** Assert */
+      expect(extensionManager.getDataSources).toHaveBeenCalledTimes(1);
+      expect(extensionManager.getDataSources).toHaveBeenCalledWith('dataSource2');
+      expect(data).toEqual(['234']);
+    });
+  });
+});

extensions/default/src/MergeDataSource/index.ts

@@ -0,0 +1,252 @@
+import { DicomMetadataStore, IWebApiDataSource } from '@ohif/core';
+import { get, uniqBy } from 'lodash';
+import {
+  MergeConfig,
+  CallForAllDataSourcesAsyncOptions,
+  CallForAllDataSourcesOptions,
+  CallForDefaultDataSourceOptions,
+  CallByRetrieveAETitleOptions,
+  MergeMap,
+} from './types';
+
+export const mergeMap: MergeMap = {
+  'query.studies.search': {
+    mergeKey: 'studyInstanceUid',
+    tagFunc: x => x,
+  },
+  'query.series.search': {
+    mergeKey: 'seriesInstanceUid',
+    tagFunc: (series, sourceName) => {
+      series.forEach(series => {
+        series.RetrieveAETitle = sourceName;
+        DicomMetadataStore.updateSeriesMetadata(series);
+      });
+      return series;
+    },
+  },
+};
+
+/**
+ * Calls all data sources asynchronously and merges the results.
+ * @param {CallForAllDataSourcesAsyncOptions} options - The options for calling all data sources.
+ * @param {string} options.path - The path to the function to be called on each data source.
+ * @param {unknown[]} options.args - The arguments to be passed to the function.
+ * @param {ExtensionManager} options.extensionManager - The extension manager.
+ * @param {string[]} options.dataSourceNames - The names of the data sources to be called.
+ * @returns {Promise<unknown[]>} - A promise that resolves to the merged data from all data sources.
+ */
+export const callForAllDataSourcesAsync = async ({
+  mergeMap,
+  path,
+  args,
+  extensionManager,
+  dataSourceNames,
+}: CallForAllDataSourcesAsyncOptions) => {
+  const { mergeKey, tagFunc } = mergeMap[path] || { tagFunc: x => x };
+
+  const dataSourceDefs = Object.values(extensionManager.dataSourceDefs);
+  const promises = [];
+  const mergedData = [];
+
+  for (const dataSourceDef of dataSourceDefs) {
+    const { configuration, sourceName } = dataSourceDef;
+    if (!!configuration && dataSourceNames.includes(sourceName)) {
+      const [dataSource] = extensionManager.getDataSources(sourceName);
+      const func = get(dataSource, path);
+      const promise = func.apply(dataSource, args);
+      promises.push(promise.then(data => mergedData.push(tagFunc(data, sourceName))));
+    }
+  }
+
+  await Promise.allSettled(promises);
+
+  return uniqBy(mergedData.flat(), obj => obj[mergeKey]);
+};
+
+/**
+ * Calls all data sources that match the provided names and merges their data.
+ * @param options - The options for calling all data sources.
+ * @param options.path - The path to the function to be called on each data source.
+ * @param options.args - The arguments to be passed to the function.
+ * @param options.extensionManager - The extension manager instance.
+ * @param options.dataSourceNames - The names of the data sources to be called.
+ * @returns The merged data from all the matching data sources.
+ */
+export const callForAllDataSources = ({
+  path,
+  args,
+  extensionManager,
+  dataSourceNames,
+}: CallForAllDataSourcesOptions) => {
+  const dataSourceDefs = Object.values(extensionManager.dataSourceDefs);
+  const mergedData = [];
+  for (const dataSourceDef of dataSourceDefs) {
+    const { configuration, sourceName } = dataSourceDef;
+    if (!!configuration && dataSourceNames.includes(sourceName)) {
+      const [dataSource] = extensionManager.getDataSources(sourceName);
+      const func = get(dataSource, path);
+      const data = func.apply(dataSource, args);
+      mergedData.push(data);
+    }
+  }
+  return mergedData.flat();
+};
+
+/**
+ * Calls the default data source function specified by the given path with the provided arguments.
+ * @param {CallForDefaultDataSourceOptions} options - The options for calling the default data source.
+ * @param {string} options.path - The path to the function within the default data source.
+ * @param {unknown[]} options.args - The arguments to pass to the function.
+ * @param {string} options.defaultDataSourceName - The name of the default data source.
+ * @param {ExtensionManager} options.extensionManager - The extension manager instance.
+ * @returns {unknown} - The result of calling the default data source function.
+ */
+export const callForDefaultDataSource = ({
+  path,
+  args,
+  defaultDataSourceName,
+  extensionManager,
+}: CallForDefaultDataSourceOptions) => {
+  const [dataSource] = extensionManager.getDataSources(defaultDataSourceName);
+  const func = get(dataSource, path);
+  return func.apply(dataSource, args);
+};
+
+/**
+ * Calls the data source specified by the RetrieveAETitle of the given display set.
+ * @typedef {Object} CallByRetrieveAETitleOptions
+ * @property {string} path - The path of the method to call on the data source.
+ * @property {unknown[]} args - The arguments to pass to the method.
+ * @property {string} defaultDataSourceName - The name of the default data source.
+ * @property {ExtensionManager} extensionManager - The extension manager.
+ */
+export const callByRetrieveAETitle = ({
+  path,
+  args,
+  defaultDataSourceName,
+  extensionManager,
+}: CallByRetrieveAETitleOptions) => {
+  const [displaySet] = args;
+  const seriesMetadata = DicomMetadataStore.getSeries(
+    displaySet.StudyInstanceUID,
+    displaySet.SeriesInstanceUID
+  );
+  const [dataSource] = extensionManager.getDataSources(
+    seriesMetadata.RetrieveAETitle || defaultDataSourceName
+  );
+  return dataSource[path](...args);
+};
+
+function createMergeDataSourceApi(
+  mergeConfig: MergeConfig,
+  UserAuthenticationService: unknown,
+  extensionManager
+) {
+  const { seriesMerge } = mergeConfig;
+  const { dataSourceNames, defaultDataSourceName } = seriesMerge;
+
+  const implementation = {
+    initialize: (...args: unknown[]) =>
+      callForAllDataSources({ path: 'initialize', args, extensionManager, dataSourceNames }),
+    query: {
+      studies: {
+        search: (...args: unknown[]) =>
+          callForAllDataSourcesAsync({
+            mergeMap,
+            path: 'query.studies.search',
+            args,
+            extensionManager,
+            dataSourceNames,
+          }),
+      },
+      series: {
+        search: (...args: unknown[]) =>
+          callForAllDataSourcesAsync({
+            mergeMap,
+            path: 'query.series.search',
+            args,
+            extensionManager,
+            dataSourceNames,
+          }),
+      },
+      instances: {
+        search: (...args: unknown[]) =>
+          callForAllDataSourcesAsync({
+            mergeMap,
+            path: 'query.instances.search',
+            args,
+            extensionManager,
+            dataSourceNames,
+          }),
+      },
+    },
+    retrieve: {
+      bulkDataURI: (...args: unknown[]) =>
+        callForAllDataSourcesAsync({
+          mergeMap,
+          path: 'retrieve.bulkDataURI',
+          args,
+          extensionManager,
+          dataSourceNames,
+        }),
+      directURL: (...args: unknown[]) =>
+        callForDefaultDataSource({
+          path: 'retrieve.directURL',
+          args,
+          defaultDataSourceName,
+          extensionManager,
+        }),
+      series: {
+        metadata: (...args: unknown[]) =>
+          callForAllDataSourcesAsync({
+            mergeMap,
+            path: 'retrieve.series.metadata',
+            args,
+            extensionManager,
+            dataSourceNames,
+          }),
+      },
+    },
+    store: {
+      dicom: (...args: unknown[]) =>
+        callForDefaultDataSource({
+          path: 'store.dicom',
+          args,
+          defaultDataSourceName,
+          extensionManager,
+        }),
+    },
+    deleteStudyMetadataPromise: (...args: unknown[]) =>
+      callForAllDataSources({
+        path: 'deleteStudyMetadataPromise',
+        args,
+        extensionManager,
+        dataSourceNames,
+      }),
+    getImageIdsForDisplaySet: (...args: unknown[]) =>
+      callByRetrieveAETitle({
+        path: 'getImageIdsForDisplaySet',
+        args,
+        defaultDataSourceName,
+        extensionManager,
+      }),
+    getImageIdsForInstance: (...args: unknown[]) =>
+      callByRetrieveAETitle({
+        path: 'getImageIdsForDisplaySet',
+        args,
+        defaultDataSourceName,
+        extensionManager,
+      }),
+    getStudyInstanceUIDs: (...args: unknown[]) =>
+      callForAllDataSources({
+        path: 'getStudyInstanceUIDs',
+        args,
+        extensionManager,
+        dataSourceNames,
+      }),
+  };
+
+  return IWebApiDataSource.create(implementation);
+}
+
+export { createMergeDataSourceApi };

extensions/default/src/MergeDataSource/types.ts

@@ -0,0 +1,44 @@
+import { ExtensionManager } from '@ohif/core';
+
+export type MergeMap = {
+  [key: string]: {
+    mergeKey: string;
+    tagFunc: (data: unknown[], sourceName: string) => unknown[];
+  };
+};
+
+export type CallForAllDataSourcesAsyncOptions = {
+  mergeMap: object;
+  path: string;
+  args: unknown[];
+  dataSourceNames: string[];
+  extensionManager: ExtensionManager;
+};
+
+export type CallForAllDataSourcesOptions = {
+  path: string;
+  args: unknown[];
+  dataSourceNames: string[];
+  extensionManager: ExtensionManager;
+};
+
+export type CallForDefaultDataSourceOptions = {
+  path: string;
+  args: unknown[];
+  defaultDataSourceName: string;
+  extensionManager: ExtensionManager;
+};
+
+export type CallByRetrieveAETitleOptions = {
+  path: string;
+  args: unknown[];
+  defaultDataSourceName: string;
+  extensionManager: ExtensionManager;
+};
+
+export type MergeConfig = {
+  seriesMerge: {
+    dataSourceNames: string[];
+    defaultDataSourceName: string;
+  };
+};