@reltio/profile 1.4.1585 → 1.4.1586-mui5

package/src/components/ProfilePotentialMatchesView/MatchCard.tsx

@@ -0,0 +1,53 @@
+import {
+    COMMENTS_CONTAINER_VISIBILITY_AREA,
+    CommentsContainer,
+    ProfileMatchCard,
+    useMatchesLoader
+} from '@reltio/components';
+import {
+    CollaborationObjectTypes,
+    createObjectIdForPM,
+    createRelatedObjectUris,
+    Match,
+    ProfilePotentialMatchesViewConfig
+} from '@reltio/mdm-sdk';
+import {ActionButtons} from './ActionButtons';
+import React from 'react';
+import {useSelector} from 'react-redux';
+import mdmModule from '@reltio/mdm-module';
+
+type Props = Pick<ReturnType<typeof useMatchesLoader>, 'entitiesMap'> & {
+    config: ProfilePotentialMatchesViewConfig;
+    match: Match;
+    onFinishRequest: () => void;
+    onStartRequest: () => void;
+};
+
+export const MatchCard = ({config, entitiesMap, match, onFinishRequest, onStartRequest}: Props) => {
+    const metadata = useSelector(mdmModule.selectors.getMetadata);
+    const entity = useSelector(mdmModule.selectors.getEntity);
+    return (
+        <ProfileMatchCard
+            match={match}
+            entity={entity}
+            entitiesMap={entitiesMap}
+            metadata={metadata}
+            className={COMMENTS_CONTAINER_VISIBILITY_AREA}
+        >
+            <CommentsContainer
+                uri={createObjectIdForPM(entity.uri, match.object.uri)}
+                relatedObjectUris={createRelatedObjectUris(CollaborationObjectTypes.POTENTIAL_MATCH, {
+                    entityUri: entity.uri,
+                    matchEntityUri: match.object.uri
+                })}
+                objectType={CollaborationObjectTypes.POTENTIAL_MATCH}
+            />
+            <ActionButtons
+                match={match}
+                config={config}
+                onStartRequest={onStartRequest}
+                onFinishRequest={onFinishRequest}
+            />
+        </ProfileMatchCard>
+    );
+};

package/src/components/ProfilePotentialMatchesView/ProfilePotentialMatchesView.tsx

@@ -0,0 +1,137 @@
+import React, {useCallback, useContext, useEffect, useMemo, useState} from 'react';
+import {useDispatch, useSelector} from 'react-redux';
+import classnames from 'classnames';
+import i18n from 'ui-i18n';
+import {isEmpty, map} from 'ramda';
+import Link from '@mui/material/Link';
+import Typography from '@mui/material/Typography';
+import {
+    BasicView,
+    CollaborationContext,
+    EntitiesMapContext,
+    FacetViewHeader,
+    LinearLoadIndicator,
+    useMatchesLoader,
+    ViewIdContext
+} from '@reltio/components';
+import mdmModule, {ui as mdmModuleUi} from '@reltio/mdm-module';
+import {
+    getEntityUriForLink,
+    getEntityUriFromMatchObject,
+    getPotentialMatchesObjectIdsForCollaboration,
+    Order,
+    ProfilePotentialMatchesViewConfig
+} from '@reltio/mdm-sdk';
+import {MatchCard} from './MatchCard';
+import {useStyles} from './styles';
+
+type Props = {
+    config: ProfilePotentialMatchesViewConfig;
+    className?: string;
+};
+
+export const DEFAULT_MATCHES_LIMIT = 3;
+export const DEFAULT_OPTIONS = {
+    showTransitiveMatches: true,
+    showInactiveEntities: false
+};
+export const DEFAULT_SORTING = {order: Order.asc, field: 'score'};
+enum ComponentStates {
+    Loading,
+    NoData,
+    Loaded
+}
+export const ProfilePotentialMatchesView = ({config, className}: Props) => {
+    const styles = useStyles();
+    const entity = useSelector(mdmModule.selectors.getEntity);
+    const entityUri = getEntityUriForLink(entity);
+
+    const [isLoading, setIsLoading] = useState(false);
+    const turnOnDisableSpinner = useCallback(() => {
+        setIsLoading(true);
+    }, []);
+    const turnOffDisableSpinner = useCallback(() => {
+        setIsLoading(false);
+    }, []);
+
+    const {matches, entitiesMap, loadMatches} = useMatchesLoader({
+        enabled: !!entityUri,
+        entity,
+        options: DEFAULT_OPTIONS,
+        filter: '',
+        page: 0,
+        sorting: DEFAULT_SORTING,
+        rowsPerPage: DEFAULT_MATCHES_LIMIT,
+        onStartLoading: turnOnDisableSpinner,
+        onFinishLoading: turnOffDisableSpinner
+    });
+    const onFinishMatchAction = useCallback(() => {
+        loadMatches();
+    }, [loadMatches]);
+
+    const dispatch = useDispatch();
+    const viewId = useContext(ViewIdContext);
+    const openPotentialMatchPerspective = useCallback(() => {
+        dispatch(mdmModuleUi.actions.openPerspective({perspectiveId: 'potentialMatches', viewId}));
+    }, [dispatch, viewId]);
+
+    const objectIds = useMemo(
+        () => getPotentialMatchesObjectIdsForCollaboration(entityUri, map(getEntityUriFromMatchObject, matches)),
+        [entityUri, matches]
+    );
+
+    const {getCommentsCount} = useContext(CollaborationContext);
+    useEffect(() => {
+        getCommentsCount(objectIds);
+    }, [getCommentsCount, objectIds]);
+
+    const showSeeAll = !isEmpty(matches);
+    const getComponentState = () => {
+        if (isLoading) {
+            return ComponentStates.Loading;
+        }
+        if (isEmpty(matches)) {
+            return ComponentStates.NoData;
+        }
+        return ComponentStates.Loaded;
+    };
+    const state = getComponentState();
+    return (
+        <EntitiesMapContext.Provider value={entitiesMap}>
+            <BasicView className={classnames(styles.root, className)}>
+                <FacetViewHeader title={config.caption} />
+                <div className={styles.matchesContainer}>
+                    {state === ComponentStates.Loading && <LinearLoadIndicator />}
+                    {state === ComponentStates.NoData && (
+                        <Typography className={styles.noData}>{i18n.text('No matches found')}</Typography>
+                    )}
+                    {state === ComponentStates.Loaded &&
+                        matches.map((match) => (
+                            <MatchCard
+                                config={config}
+                                entitiesMap={entitiesMap}
+                                match={match}
+                                onFinishRequest={onFinishMatchAction}
+                                onStartRequest={turnOnDisableSpinner}
+                                key={match.object.uri}
+                            />
+                        ))}
+                </div>
+                {showSeeAll && (
+                    <>
+                        <div className={styles.footer}>
+                            <Link
+                                component="button"
+                                variant="caption"
+                                onClick={openPotentialMatchPerspective}
+                                underline="none"
+                            >
+                                {i18n.text('See all')}
+                            </Link>
+                        </div>
+                    </>
+                )}
+            </BasicView>
+        </EntitiesMapContext.Provider>
+    );
+};

package/src/components/ProfilePotentialMatchesView/__tests__/ActionButtons.specs.tsx

@@ -0,0 +1,89 @@
+import React from 'react';
+import {mount} from 'enzyme';
+import {ActionButtons} from '../ActionButtons';
+import * as reactRedux from 'react-redux';
+import {getActionPermissionForMatch} from '@reltio/mdm-sdk';
+import mdmModule, {profile} from '@reltio/mdm-module';
+import {config, currentEntity, matches, metadata} from './commonData';
+import {ActionButtonMode, ViewIdContext} from '@reltio/components';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getActionPermissionForMatch: jest.fn()
+}));
+
+const MergeButtonMock = () => <div className="MergeButtonMock" />;
+const NotMatchButtonMock = () => <div className="NotMatchButtonMock" />;
+
+jest.mock('@reltio/components', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/components'),
+    MergeButton: MergeButtonMock,
+    NotMatchButton: NotMatchButtonMock
+}));
+
+describe('ActionsButtons tests', () => {
+    const getMergeButton = (component) => component.find(MergeButtonMock);
+    const getNotMatchButton = (component) => component.find(NotMatchButtonMock);
+    const match = matches[0];
+    const onStartRequest = jest.fn();
+    const onFinishRequest = jest.fn();
+    const dispatch = jest.fn();
+    beforeAll(() => {
+        jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(undefined));
+        jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(dispatch);
+        jest.spyOn(mdmModule.selectors, 'getMetadata').mockReturnValue(metadata);
+        jest.spyOn(mdmModule.selectors, 'getEntity').mockReturnValue(currentEntity);
+    });
+
+    beforeEach(() => {
+        (getActionPermissionForMatch as jest.Mock).mockReturnValue({canMerge: true, canMark: true});
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    const viewId = 'id1';
+    const setUp = () =>
+        mount(
+            <ViewIdContext.Provider value={viewId}>
+                <ActionButtons
+                    config={config}
+                    match={match}
+                    onStartRequest={onStartRequest}
+                    onFinishRequest={onFinishRequest}
+                />
+            </ViewIdContext.Provider>
+        );
+    it('should show button if user have permission', () => {
+        const component = setUp();
+        expect(getMergeButton(component)).toHaveLength(1);
+        expect(getNotMatchButton(component)).toHaveLength(1);
+    });
+
+    it('should not show button if user do not have permission', () => {
+        (getActionPermissionForMatch as jest.Mock).mockReturnValue({canMerge: false, canMark: false});
+        const component = setUp();
+        expect(getMergeButton(component)).toHaveLength(0);
+        expect(getNotMatchButton(component)).toHaveLength(0);
+    });
+
+    it('should call onFinishRequest and dispatch loadEntity action for merge button', () => {
+        const component = setUp();
+        getMergeButton(component).prop('onFinishRequest')();
+        expect(onFinishRequest).toHaveBeenCalled();
+        expect(dispatch).toHaveBeenCalledWith(profile.entity.actions.loadEntity({viewId, uri: currentEntity.uri}));
+    });
+
+    it('should provide properties for MergeButton and NotMatchButton ', () => {
+        const component = setUp();
+        const mergeButtonProps = getMergeButton(component).props();
+        expect(mergeButtonProps.entity).toBe(currentEntity);
+        expect(mergeButtonProps.mode).toBe(ActionButtonMode.iconButton);
+        expect(mergeButtonProps.onStartRequest).toBe(onStartRequest);
+        const notMatchButtonProps = getNotMatchButton(component).props();
+        expect(notMatchButtonProps.entity).toBe(currentEntity);
+        expect(notMatchButtonProps.mode).toBe(ActionButtonMode.iconButton);
+        expect(notMatchButtonProps.onStartRequest).toBe(onStartRequest);
+        expect(notMatchButtonProps.onFinishRequest).toBe(onFinishRequest);
+    });
+});

package/src/components/ProfilePotentialMatchesView/__tests__/MatchCard.specs.tsx

@@ -0,0 +1,62 @@
+import React from 'react';
+import * as reactRedux from 'react-redux';
+import {shallow} from 'enzyme';
+import mdmModule from '@reltio/mdm-module';
+import {config, currentEntity, matches, metadata} from './commonData';
+import {MatchCard} from '../MatchCard';
+import {COMMENTS_CONTAINER_VISIBILITY_AREA, CommentsContainer, ProfileMatchCard} from '@reltio/components';
+import {ActionButtons} from '../ActionButtons';
+import {CollaborationObjectTypes} from '@reltio/mdm-sdk';
+
+describe('MatchCard test', () => {
+    const getCommentsContainer = (component) => component.find(CommentsContainer);
+    const getProfileMatchCard = (component) => component.find(ProfileMatchCard);
+    const getActionButtons = (component) => component.find(ActionButtons);
+    const match = matches[0];
+    const onFinishRequest = jest.fn();
+    const onStartRequest = jest.fn();
+    const entitiesMap = {'entities/1Gw3QsjR': {label: 'label', uri: 'uri', type: 'type'}};
+    const setUp = () =>
+        shallow(
+            <MatchCard
+                config={config}
+                entitiesMap={entitiesMap}
+                match={match}
+                onFinishRequest={onFinishRequest}
+                onStartRequest={onStartRequest}
+            />
+        );
+
+    beforeAll(() => {
+        jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(undefined));
+        jest.spyOn(mdmModule.selectors, 'getMetadata').mockReturnValue(metadata);
+        jest.spyOn(mdmModule.selectors, 'getEntity').mockReturnValue(currentEntity);
+    });
+
+    it('should render components well', () => {
+        const component = setUp();
+        expect(getProfileMatchCard(component)).toHaveLength(1);
+        expect(getProfileMatchCard(component).props()).toMatchObject({
+            match,
+            entity: currentEntity,
+            entitiesMap: entitiesMap,
+            metadata,
+            className: COMMENTS_CONTAINER_VISIBILITY_AREA
+        });
+
+        expect(getCommentsContainer(component)).toHaveLength(1);
+        expect(getCommentsContainer(component).props()).toEqual({
+            objectType: CollaborationObjectTypes.POTENTIAL_MATCH,
+            uri: `${match.object.uri}-${currentEntity.uri}`,
+            relatedObjectUris: [currentEntity.uri, match.object.uri]
+        });
+
+        expect(getActionButtons(component)).toHaveLength(1);
+        expect(getActionButtons(component).props()).toEqual({
+            match,
+            config,
+            onStartRequest,
+            onFinishRequest
+        });
+    });
+});

package/src/components/ProfilePotentialMatchesView/__tests__/ProfilePotentialMatchesView.specs.tsx

@@ -0,0 +1,267 @@
+import React from 'react';
+import {mount} from 'enzyme';
+import {map, pipe, take} from 'ramda';
+import {
+    BasicView,
+    FacetViewHeader,
+    CollaborationContext,
+    LinearLoadIndicator,
+    ViewIdContext,
+    EntitiesMapContext
+} from '@reltio/components';
+import {
+    getActionPermissionForMatches,
+    getEntityUriFromMatchObject,
+    getMatchesFromDataTenants,
+    getPotentialMatchesObjectIdsForCollaboration,
+    getTransitiveMatches
+} from '@reltio/mdm-sdk';
+import mdmModule, {ui as mdmModuleUi} from '@reltio/mdm-module';
+import * as reactRedux from 'react-redux';
+import {act} from 'react-dom/test-utils';
+import {DEFAULT_MATCHES_LIMIT, DEFAULT_SORTING, ProfilePotentialMatchesView} from '../ProfilePotentialMatchesView';
+import Link from '@mui/material/Link';
+import {config, currentEntity, matches} from './commonData';
+
+jest.mock('@reltio/mdm-sdk', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/mdm-sdk'),
+    getActionPermissionForMatches: jest.fn(),
+    getTransitiveMatches: jest.fn(),
+    getMatchesFromDataTenants: jest.fn(),
+    getCommentsCount: jest.fn()
+}));
+
+const MatchCardMock = () => <div className="MatchCardMock" />;
+jest.mock('../MatchCard', () => ({
+    MatchCard: MatchCardMock
+}));
+
+jest.mock('@reltio/components', () => ({
+    ...jest.requireActual<Record<string, unknown>>('@reltio/components'),
+    EntitiesMapContext: {
+        Provider: jest.fn()
+    }
+}));
+
+describe('ProfilePotentialMatchesView tests', () => {
+    const className = 'test className';
+
+    const dispatch = jest.fn();
+    const dataTenants = [{id: 'dt1'}];
+
+    const getMatchCard = (component) => component.find(MatchCardMock);
+    const getBasicView = (component) => component.find(BasicView);
+    const getFacetViewHeader = (component) => component.find(FacetViewHeader);
+    const getLink = (component) => component.find(Link);
+    const getLinearLoadIndicator = (component) => component.find(LinearLoadIndicator);
+    const getFooter = (component) => component.find('.footer');
+    const getMatchesContainer = (component) => component.find('.matchesContainer');
+    const getNoDataComponent = (component) => component.find('p.noData');
+
+    const testTenant = 'test Tenant';
+    const dtssPath = 'dtssPath/';
+    const collaborationPath = 'https://cservice-dev.reltio.com/reltio-collaboration/tst-01';
+    beforeAll(() => {
+        jest.spyOn(reactRedux, 'useSelector').mockImplementation((selector) => selector(undefined));
+        jest.spyOn(reactRedux, 'useDispatch').mockReturnValue(dispatch);
+
+        (EntitiesMapContext.Provider as any).mockImplementation(({children}) => (
+            <div id="entitiesMapContextMock">{children}</div>
+        ));
+    });
+
+    beforeEach(() => {
+        (getTransitiveMatches as jest.Mock).mockReturnValue(Promise.resolve(matches));
+        (getMatchesFromDataTenants as jest.Mock).mockReturnValue(Promise.resolve(matches));
+        (getActionPermissionForMatches as jest.Mock).mockReturnValue({canMerge: true, canMark: true});
+        jest.spyOn(mdmModule.selectors, 'getEntity').mockReturnValue(currentEntity);
+        jest.spyOn(mdmModule.selectors, 'getTenant').mockReturnValue(testTenant);
+        jest.spyOn(mdmModule.selectors, 'getDtssPath').mockReturnValue(dtssPath);
+        jest.spyOn(mdmModule.selectors, 'getGlobalSearchRequestOptions').mockReturnValue({
+            activityFilter: 'active',
+            globalFilter: '',
+            searchOptions: {}
+        });
+        jest.spyOn(mdmModule.selectors, 'getDataTenants').mockReturnValue(dataTenants);
+        jest.spyOn(mdmModule.selectors, 'isCollaborationEnabled').mockReturnValue(true);
+        jest.spyOn(mdmModule.selectors, 'getCollaborationPath').mockReturnValue(collaborationPath);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    const setUp = async ({viewId = 'id1'} = {viewId: 'id1'}) => {
+        let component;
+        await act(async () => {
+            component = mount(
+                <ViewIdContext.Provider value={viewId}>
+                    <ProfilePotentialMatchesView config={config} className={className} />
+                </ViewIdContext.Provider>
+            );
+        });
+        return component;
+    };
+
+    it('should render basics components well', async () => {
+        const component = await setUp();
+        await component.update();
+
+        expect(getMatchesFromDataTenants).toHaveBeenCalled();
+
+        expect(component.find(EntitiesMapContext.Provider).prop('value')).toEqual({
+            'entities/1Gw3QsjR': {
+                type: 'configuration/entityTypes/HCP',
+                uri: 'entities/1Gw3QsjR'
+            },
+            'entities/1HM8WlMC': {
+                type: 'configuration/entityTypes/HCP',
+                uri: 'entities/1HM8WlMC'
+            },
+            'entities/1XL8k30v': {
+                type: 'configuration/entityTypes/HCP',
+                uri: 'entities/1XL8k30v'
+            },
+            'entities/2WiVGZTQ': {
+                type: 'configuration/entityTypes/HCP',
+                uri: 'entities/2WiVGZTQ'
+            }
+        });
+        expect(getBasicView(component).prop('className')).toContain(className);
+        expect(getFacetViewHeader(component).prop('title')).toBe(config.caption);
+        expect(getMatchCard(component)).toHaveLength(DEFAULT_MATCHES_LIMIT);
+        expect(getLink(component).text()).toBe('See all');
+    });
+
+    it('should render LinearLoadIndicator and hide footer and no data label while loading', async () => {
+        const component = mount(
+            <ViewIdContext.Provider value={'id1'}>
+                <ProfilePotentialMatchesView config={config} className={className} />
+            </ViewIdContext.Provider>
+        );
+        expect(getLinearLoadIndicator(component)).toHaveLength(1);
+        expect(getNoDataComponent(component)).toHaveLength(0);
+        expect(getFooter(component)).toHaveLength(0);
+        await act(async () => {
+            await Promise.resolve();
+        });
+        await component.update();
+        expect(getFooter(component)).toHaveLength(1);
+        expect(getLinearLoadIndicator(component)).toHaveLength(0);
+    });
+
+    it('should render footer when matches even if we have the only match', async () => {
+        (getTransitiveMatches as jest.Mock).mockReturnValue(Promise.resolve([matches[0]]));
+        (getMatchesFromDataTenants as jest.Mock).mockReturnValue(Promise.resolve([matches[0]]));
+        const component = await setUp();
+        await component.update();
+        expect(getFooter(component)).toHaveLength(1);
+    });
+
+    it('should show empty state', async () => {
+        (getTransitiveMatches as jest.Mock).mockReturnValue(Promise.resolve([]));
+        (getMatchesFromDataTenants as jest.Mock).mockReturnValue(Promise.resolve([]));
+        const component = await setUp();
+        await component.update();
+        expect(getNoDataComponent(component)).toHaveLength(1);
+        expect(getMatchesContainer(component).text()).toBe('No matches found');
+        expect(getFooter(component)).toHaveLength(0);
+    });
+    it('should dispatch action for open potantial-matches perspective', async () => {
+        const viewId = 'id1';
+        let component;
+        await act(async () => {
+            component = mount(
+                <ViewIdContext.Provider value={viewId}>
+                    <ProfilePotentialMatchesView config={config} className={className} />
+                </ViewIdContext.Provider>
+            );
+        });
+        await component.update();
+        act(() => {
+            getLink(component).prop('onClick')();
+        });
+        expect(dispatch).toHaveBeenCalledWith(
+            mdmModuleUi.actions.openPerspective({perspectiveId: 'potentialMatches', viewId})
+        );
+    });
+    describe('useMatchesLoader behaviour', () => {
+        it('should call getMatchesFromDataTenants', async () => {
+            await act(async () => {
+                mount(
+                    <ViewIdContext.Provider value="id1">
+                        <ProfilePotentialMatchesView config={config} className={className} />
+                    </ViewIdContext.Provider>
+                );
+            });
+            expect(getMatchesFromDataTenants).toHaveBeenCalledWith({
+                customerTenant: testTenant,
+                dataTenants: dataTenants,
+                dtssPath,
+                entity: currentEntity
+            });
+        });
+        it('should call getTransitiveMatches', async () => {
+            await act(async () => {
+                mount(
+                    <ViewIdContext.Provider value="id1">
+                        <ProfilePotentialMatchesView config={config} className={className} />
+                    </ViewIdContext.Provider>
+                );
+            });
+            expect(getTransitiveMatches).toHaveBeenCalledWith({
+                order: DEFAULT_SORTING.order,
+                sort: DEFAULT_SORTING.field,
+                deep: undefined,
+                activeness: 'active',
+                entityUri: currentEntity.uri,
+                filter: ''
+            });
+        });
+        it('should not call getTransitiveMatches when entity uri is undefined', async () => {
+            jest.spyOn(mdmModule.selectors, 'getEntity').mockReturnValue(null);
+            await act(async () => {
+                mount(
+                    <ViewIdContext.Provider value="id1">
+                        <ProfilePotentialMatchesView config={config} className={className} />
+                    </ViewIdContext.Provider>
+                );
+            });
+            expect(getTransitiveMatches).not.toHaveBeenCalled();
+        });
+
+        it('should return empty for temp entity', async () => {
+            jest.spyOn(mdmModule.selectors, 'getEntity').mockReturnValue({
+                uri: 'uri$$Temp',
+                type: 'configuration/entityTypes/HCP'
+            });
+            const component = await setUp();
+            await component.update();
+            expect(getMatchCard(component)).toHaveLength(0);
+            expect(getMatchesContainer(component).text()).toBe('No matches found');
+            expect(getTransitiveMatches).not.toHaveBeenCalled();
+        });
+    });
+    describe('useCollaboration behaviour', () => {
+        it('should call getCommentsCount', async () => {
+            const getCommentsCountFn = jest.fn();
+            await act(async () => {
+                mount(
+                    <ViewIdContext.Provider value="id1">
+                        <CollaborationContext.Provider value={{getCommentsCount: getCommentsCountFn} as any}>
+                            <ProfilePotentialMatchesView config={config} className={className} />
+                        </CollaborationContext.Provider>
+                    </ViewIdContext.Provider>
+                );
+            });
+            await act(async () => {
+                await Promise.resolve();
+            });
+            expect(getCommentsCountFn).toHaveBeenCalledWith(
+                getPotentialMatchesObjectIdsForCollaboration(
+                    currentEntity.uri,
+                    pipe(take(DEFAULT_MATCHES_LIMIT), map(getEntityUriFromMatchObject))(matches)
+                )
+            );
+        });
+    });
+});