@natlibfi/melinda-record-matching 4.4.0-alpha.1 → 5.0.0-alpha.2

package/dist/index.js

@@ -1,59 +1,10 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.matchDetection = exports.default = exports.candidateSearch = void 0;
-var _debug = _interopRequireDefault(require("debug"));
-var _candidateSearch = _interopRequireWildcard(require("./candidate-search"));
-var candidateSearch = _candidateSearch;
-exports.candidateSearch = _candidateSearch;
-var _matchDetection = _interopRequireWildcard(require("./match-detection"));
-var matchDetection = _matchDetection;
-exports.matchDetection = _matchDetection;
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
-*
-* This file is part of melinda-record-matching-js
-*
-* melinda-record-matching-js program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation, either version 3 of the
-* License, or (at your option) any later version.
-*
-* melinda-record-matching-js is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*
-* @licend  The above is the entire license notice
-* for the JavaScript code in this file.
-*
-*/
-//import inspect from 'util';
-var _default = ({
-  detection: detectionOptions,
-  search: searchOptions,
-  maxMatches = 1,
-  maxCandidates = 25,
-  returnStrategy = false,
-  returnQuery = false,
-  returnNonMatches = false,
-  returnFailures = false
-}) => {
-  const debug = (0, _debug.default)('@natlibfi/melinda-record-matching:index');
-  const debugData = debug.extend('data');
+import createDebugLogger from "debug";
+import createSearchInterface, * as candidateSearch from "./candidate-search/index.js";
+import createDetectionInterface, * as matchDetection from "./match-detection/index.js";
+export { candidateSearch, matchDetection };
+export default ({ detection: detectionOptions, search: searchOptions, maxMatches = 1, maxCandidates = 25, returnStrategy = false, returnQuery = false, returnNonMatches = false }) => {
+  const debug = createDebugLogger("@natlibfi/melinda-record-matching:index");
+  const debugData = debug.extend("data");
   debugData(`DetectionOptions: ${JSON.stringify(detectionOptions)}`);
   debugData(`SearchOptions: ${JSON.stringify(searchOptions)}`);
   debugData(`MaxMatches: ${JSON.stringify(maxMatches)}`);
@@ -61,416 +12,134 @@ var _default = ({
   debugData(`ReturnStrategy: ${JSON.stringify(returnStrategy)}`);
   debugData(`ReturnQuery: ${JSON.stringify(returnQuery)}`);
   debugData(`ReturnNonMatches: ${JSON.stringify(returnNonMatches)}`);
-  debugData(`ReturnFailures: ${JSON.stringify(returnFailures)}`);
-  const detect = (0, _matchDetection.default)(detectionOptions, returnStrategy);
-  return ({
-    record,
-    recordExternal = {
-      recordSource: 'incomingRecord',
-      label: 'ic'
-    }
-  }) => {
-    const search = (0, _candidateSearch.default)({
-      ...searchOptions,
-      record,
-      maxCandidates,
-      recordExternal
-    });
+  const detect = createDetectionInterface(detectionOptions, returnStrategy);
+  return prepareSearch;
+  async function prepareSearch({ record, recordExternal = { recordSource: "incomingRecord", label: "ic" } }) {
+    const { search } = await createSearchInterface({ ...searchOptions, record, maxCandidates, recordExternal });
     return iterate({});
-
-    // candidateCount : amount of candidate records retrived from SRU for matching, NOT including current record set
-    // matches : candidates that have been detected as matches by current matcher job
-    // nonMatches : candidates that have been detected as non-matches by current matcher job (only if returnNonMatches is 'true')
-    // duplicateCount : amount of candidate records that were retrieved from the SRU but not handled further because they were already found in the matches/nonMatches
-
-    // state.totalRecords : amount of candidate records available to the current query (undefined, if there was no queries left)
-    // state.query : current query (undefined if there was no queries left)
-    // state.searchCounter : sequence for current search for current query (undefined, if there we no queries left)
-    // state.queryCandidateCounter: amount of candidate records retrieved from SRU for matching for current query, including the current record set (undefined if there were no queries left)
-    // state.queriesLeft : amount of queries left
-    // state.queryCounter : sequence for current query
-    // state.maxedQueries : queries that resulted in more than serverMaxResults hits
-
-    async function iterate({
-      initialState = {},
-      matches = [],
-      candidateCount = 0,
-      nonMatches = [],
-      duplicateCount = 0,
-      nonMatchCount = 0,
-      conversionFailures = [],
-      matchErrors = []
-    }) {
+    async function iterate({ initialState = {}, matches = [], candidateCount = 0, nonMatches = [], duplicateCount = 0, nonMatchCount = 0, matchErrors = [] }) {
       debugData(`Starting next matcher iteration.`);
-      const {
-        records,
-        failures,
-        ...state
-      } = await search(initialState);
-      debugData(`Current state: ${JSON.stringify(state)}, matches: ${matches.length}, candidateCount: ${candidateCount}, nonMatches: ${nonMatches.length}, nonMatchCount: ${nonMatchCount}, conversionFailures: ${conversionFailures}, matchErrors: ${matchErrors.length}`);
+      const { records, ...state } = await search(initialState);
+      debugData(`Current state: ${JSON.stringify(state)}, matches: ${matches.length}, candidateCount: ${candidateCount}, nonMatches: ${nonMatches.length}, nonMatchCount: ${nonMatchCount}, matchErrors: ${matchErrors.length}`);
       const recordSetSize = records.length;
-      const failureSetSize = failures.length;
-      const newCandidateCount = candidateCount + recordSetSize + failureSetSize;
-      const newConversionFailures = conversionFailures.concat(failures);
-      debugData(`Failures: ${failures.length}, ConversionFailures: ${conversionFailures.length}, NewConversionFailures: ${newConversionFailures.length}`);
+      const newCandidateCount = candidateCount + recordSetSize;
       if (recordSetSize > 0) {
         return handleRecordSet();
       }
       if (state.queriesLeft > 0) {
         debug(`Empty record set ${state.searchCounter} for ${state.query}, but there are ${state.queriesLeft} queries left`);
-        return iterate({
-          initialState: state,
-          matches,
-          candidateCount: newCandidateCount,
-          nonMatches,
-          nonMatchCount,
-          duplicateCount,
-          conversionFailures: newConversionFailures,
-          matchErrors
-        });
+        return iterate({ initialState: state, matches, candidateCount: newCandidateCount, nonMatches, nonMatchCount, duplicateCount, matchErrors });
       }
       debug(`No (more) candidate records to check, no more queries left, matches: ${matches.length}`);
-      return returnResult({
-        matches,
-        state,
-        stopReason: '',
-        nonMatches,
-        nonMatchCount,
-        candidateCount: newCandidateCount,
-        duplicateCount,
-        conversionFailures: newConversionFailures,
-        matchErrors
-      });
+      return returnResult({ matches, state, stopReason: "", nonMatches, nonMatchCount, candidateCount: newCandidateCount, duplicateCount, matchErrors });
       function handleRecordSet() {
         debug(`Checking record set of ${recordSetSize} candidate records for possible matches, found by ${state.searchCounter} search for ${state.query}`);
-        const matchResult = iterateRecords({
-          records,
-          recordSetSize,
-          maxMatches,
-          matches,
-          nonMatches,
-          nonMatchCount
-        });
+        const matchResult = iterateRecords({ records, recordSetSize, maxMatches, matches, nonMatches, nonMatchCount });
         const newDuplicateCount = duplicateCount + matchResult.duplicateCount;
         const newNonMatchCount = nonMatchCount + matchResult.nonMatchCount;
-        const {
-          newMatches,
-          newNonMatches,
-          newMatchErrors
-        } = handleMatchResult(matchResult, matches, nonMatches, matchErrors);
-        if (maxMatchesFound({
-          matches: newMatches,
-          maxMatches
-        })) {
-          return returnResult({
-            matches: newMatches,
-            state,
-            stopReason: 'maxMatches',
-            nonMatches: newNonMatches,
-            duplicateCount: newDuplicateCount,
-            candidateCount: newCandidateCount,
-            nonMatchCount: newNonMatchCount,
-            conversionFailures: newConversionFailures,
-            matchErrors: newMatchErrors
-          });
+        const { newMatches, newNonMatches, newMatchErrors } = handleMatchResult(matchResult, matches, nonMatches, matchErrors);
+        if (maxMatchesFound({ matches: newMatches, maxMatches })) {
+          return returnResult({ matches: newMatches, state, stopReason: "maxMatches", nonMatches: newNonMatches, duplicateCount: newDuplicateCount, candidateCount: newCandidateCount, nonMatchCount: newNonMatchCount, matchErrors: newMatchErrors });
         }
         if (maxCandidatesRetrieved(newCandidateCount, maxCandidates)) {
-          return returnResult({
-            matches: newMatches,
-            state,
-            stopReason: 'maxCandidates',
-            nonMatches: newNonMatches,
-            duplicateCount: newDuplicateCount,
-            candidateCount: newCandidateCount,
-            nonMatchCount: newNonMatchCount,
-            conversionFailures: newConversionFailures,
-            matchErrors: newMatchErrors
-          });
+          return returnResult({ matches: newMatches, state, stopReason: "maxCandidates", nonMatches: newNonMatches, duplicateCount: newDuplicateCount, candidateCount: newCandidateCount, nonMatchCount: newNonMatchCount, matchErrors: newMatchErrors });
         }
-        return iterate({
-          initialState: state,
-          matches: newMatches,
-          candidateCount: newCandidateCount,
-          nonMatches: newNonMatches,
-          duplicateCount: newDuplicateCount,
-          nonMatchCount: newNonMatchCount,
-          conversionFailures: newConversionFailures,
-          matchErrors: newMatchErrors
-        });
+        return iterate({ initialState: state, matches: newMatches, candidateCount: newCandidateCount, nonMatches: newNonMatches, duplicateCount: newDuplicateCount, nonMatchCount: newNonMatchCount, matchErrors: newMatchErrors });
       }
-      function handleMatchResult(matchResult, matches, nonMatches, matchErrors) {
+      function handleMatchResult(matchResult, matches2, nonMatches2, matchErrors2) {
         debugData(`- Amount of new matches from record set: ${matchResult.matches.length}`);
-        // eslint-disable-next-line functional/no-conditional-statements
         if (returnNonMatches) {
           debugData(`- Amount of new nonMatches from record set: ${matchResult.nonMatches.length}`);
         }
-        const newMatches = matches.concat(returnQuery ? addQuery(matchResult.matches) : matchResult.matches);
-        const newNonMatches = returnNonMatches ? nonMatches.concat(returnQuery ? addQuery(matchResult.nonMatches) : matchResult.nonMatches) : [];
-        const newMatchErrors = matchErrors.concat(matchResult.matchErrors);
+        const newMatches = matches2.concat(returnQuery ? addQuery(matchResult.matches) : matchResult.matches);
+        const newNonMatches = returnNonMatches ? nonMatches2.concat(returnQuery ? addQuery(matchResult.nonMatches) : matchResult.nonMatches) : [];
+        const newMatchErrors = matchErrors2.concat(matchResult.matchErrors);
         debugData(`- Total amount of matches: ${newMatches.length}`);
-        // eslint-disable-next-line functional/no-conditional-statements
         if (returnNonMatches) {
           debugData(`- Total amount of nonMatches: ${newNonMatches.length}`);
         }
         debugData(`MatchResult: ${JSON.stringify(matchResult)}`);
-        debugData(`Old matchErrors: ${JSON.stringify(matchErrors)}, matchErrors from matchResult: ${JSON.stringify(matchResult.matchErrors)}, New matchErrors: ${JSON.stringify(newMatchErrors)}`);
+        debugData(`Old matchErrors: ${JSON.stringify(matchErrors2)}, matchErrors from matchResult: ${JSON.stringify(matchResult.matchErrors)}, New matchErrors: ${JSON.stringify(newMatchErrors)}`);
         debugData(`- Total amount of matchErrors: ${newMatchErrors.length}`);
-        return {
-          newMatches,
-          newNonMatches,
-          newMatchErrors
-        };
+        return { newMatches, newNonMatches, newMatchErrors };
       }
-      function addQuery(matches) {
+      function addQuery(matches2) {
         debugData(`Adding query ${state.query} to matches`);
-        return matches.map(match => ({
-          ...match,
-          matchQuery: state.query
-        }));
+        return matches2.map((match) => ({ ...match, matchQuery: state.query }));
       }
-      function maxCandidatesRetrieved(candidateCount, maxCandidates) {
-        debugData(`Total amount of candidate records retrieved: ${newCandidateCount} (max: ${maxCandidates})`);
-        if (maxCandidates && candidateCount >= maxCandidates) {
-          debug(`Stopped matching because maximum number of candidate records ${candidateCount} / ${maxCandidates} have been retrieved`);
+      function maxCandidatesRetrieved(candidateCount2, maxCandidates2) {
+        debugData(`Total amount of candidate records retrieved: ${newCandidateCount} (max: ${maxCandidates2})`);
+        if (maxCandidates2 && candidateCount2 >= maxCandidates2) {
+          debug(`Stopped matching because maximum number of candidate records ${candidateCount2} / ${maxCandidates2} have been retrieved`);
           return true;
         }
       }
     }
-
-    // matches : array of matching candidate records
-    // nonMatches : array of nonMatching candidate records (if returnNonMatches option is true, otherwise empty array)
-    // - candidate.id
-    // - candidate.record
-    // - probability
-    // - strategy (if returnStrategy option is true)
-    // - treshold (if returnStrategy option is true)
-    // - matchQuery (if returnQuery option is true)
-    // failures: array of conversionFailures from candidate-search and matchErrors from matchDetection in error format {status, payload: {message, id}} if returnFailures is true
-
-    // we could have here also returnRecords/returnMatchRecords/returnNonMatchRecord options that could be turned false for not to return actual record data
-
-    // matchStatus.status: boolean, true if matcher retrieved and handled all found candidate records, false if it did not
-    // matchStatus.stopReason: string ('maxMatches','maxCandidates','maxedQueries','conversionFailures', empty string/undefined), reason for stopping retrieving or handling the candidate records
-    // - only one stopReason is returned (if there would be several possible stopReasons, stopReason is picked in the above order)
-    // - currently stopReason can be non-empty also in cases where status is true, if matcher hit the stop reason when handling the last available candidate record
-
-    function returnResult({
-      matches,
-      state,
-      stopReason,
-      nonMatches,
-      duplicateCount,
-      candidateCount,
-      nonMatchCount,
-      conversionFailures,
-      matchErrors
-    }) {
-      const conversionFailureCount = conversionFailures.length;
+    function returnResult({ matches, state, stopReason, nonMatches, duplicateCount, candidateCount, nonMatchCount, matchErrors }) {
       const matchErrorCount = matchErrors.length;
-      checkCounts({
-        matches,
-        nonMatches,
-        candidateCount,
-        duplicateCount,
-        nonMatchCount,
-        conversionFailureCount,
-        matchErrorCount
-      });
-      const matchStatus = getMatchState(state, stopReason, conversionFailureCount, matchErrorCount);
-      // add nonMatches to result only if returnNonMatches is 'true', otherwise nonMatches have not been gathered
-      const matchesResult = returnNonMatches ? {
-        matches,
-        matchStatus,
-        nonMatches,
-        candidateCount
-      } : {
-        matches,
-        matchStatus,
-        candidateCount
-      };
-      const failures = [...conversionFailures, ...matchErrors];
-      const result = returnFailures ? {
-        ...matchesResult,
-        conversionFailures: failures
-      } : matchesResult;
-      debugData(`ReturnFailures ${returnFailures}`);
+      checkCounts({ matches, nonMatches, candidateCount, duplicateCount, nonMatchCount, matchErrorCount });
+      const matchStatus = getMatchState(state, stopReason, matchErrorCount);
+      const matchesResult = returnNonMatches ? { matches, matchStatus, nonMatches, candidateCount } : { matches, matchStatus, candidateCount };
+      const result = matchesResult;
       debugData(`${JSON.stringify(result)}`);
       return result;
-
-      // note that in cases where the matching has been stopped because of maxMatches checkCounts won't (in most cases) match
-
-      function checkCounts({
-        matches,
-        nonMatches,
-        candidateCount,
-        duplicateCount,
-        nonMatchCount,
-        conversionFailureCount,
-        matchErrorCount
-      }) {
-        const matchCount = matches.length;
+      function checkCounts({ matches: matches2, nonMatches: nonMatches2, candidateCount: candidateCount2, duplicateCount: duplicateCount2, nonMatchCount: nonMatchCount2, matchErrorCount: matchErrorCount2 }) {
+        const matchCount = matches2.length;
         debugData(`Return nonMatches: ${returnNonMatches}`);
-        const chosenNonMatchCount = returnNonMatches ? nonMatches.length : nonMatchCount;
-        const totalHandled = matchCount + chosenNonMatchCount + duplicateCount;
-        debug(`candidateCount: ${candidateCount}, matches: ${matchCount}, nonMatches: ${chosenNonMatchCount}, duplicateCount: ${duplicateCount}, conversionFailureCount: ${conversionFailureCount}, matchErrorCount: ${matchErrorCount}`);
-        debug(`We got result for ${totalHandled} / ${candidateCount} retrieved candidates`);
-        if (totalHandled !== candidateCount) {
-          debug(`WARNING: Missing results for ${candidateCount - totalHandled} candidates`);
+        const chosenNonMatchCount = returnNonMatches ? nonMatches2.length : nonMatchCount2;
+        const totalHandled = matchCount + chosenNonMatchCount + duplicateCount2;
+        debug(`candidateCount: ${candidateCount2}, matches: ${matchCount}, nonMatches: ${chosenNonMatchCount}, duplicateCount: ${duplicateCount2}, matchErrorCount: ${matchErrorCount2}`);
+        debug(`We got result for ${totalHandled} / ${candidateCount2} retrieved candidates`);
+        if (totalHandled !== candidateCount2) {
+          debug(`WARNING: Missing results for ${candidateCount2 - totalHandled} candidates`);
           return;
         }
         return;
       }
-
-      // eslint-disable-next-line max-statements
-      function getMatchState(state, stopReason, conversionFailuresCount, matchErrorCount) {
-        debugData(`${JSON.stringify(state)}`);
-        debug(`We had ${conversionFailuresCount} retrieved candidates that could not be converted.`);
-        debug(`We had ${matchErrorCount} retrieved candidates that errored in matchDetection.`);
-        debug(`Queries left ${state.queriesLeft}, Searches for current query left: ${state.resultSetOffset && state.resultSetOffset <= state.totalRecords}, non-retrieved records: ${state.totalRecords - state.queryCandidateCounter}, maxedQueries (${state.maxedQueries.length}): ${state.maxedQueries}`);
-        debugData(`StopReason: <${stopReason}>`);
-        const searchesLeft = state.resultSetOffset && state.resultSetOffset <= state.totalRecords;
-        const nonRetrieved = searchesLeft ? state.totalRecords - state.queryCandidateCounter : 0;
+      function getMatchState(state2, stopReason2, matchErrorCount2) {
+        debugData(`${JSON.stringify(state2)}`);
+        debug(`We had ${matchErrorCount2} retrieved candidates that errored in matchDetection.`);
+        debug(`Queries left ${state2.queriesLeft}, Searches for current query left: ${state2.resultSetOffset && state2.resultSetOffset <= state2.totalRecords}, non-retrieved records: ${state2.totalRecords - state2.queryCandidateCounter}, maxedQueries (${state2.maxedQueries.length}): ${state2.maxedQueries}`);
+        debugData(`StopReason: <${stopReason2}>`);
+        const searchesLeft = state2.resultSetOffset && state2.resultSetOffset <= state2.totalRecords;
+        const nonRetrieved = searchesLeft ? state2.totalRecords - state2.queryCandidateCounter : 0;
         debugData(`nonRetrieved: ${nonRetrieved}`);
-
-        // matchStatus.stopReason: string ('maxMatches','maxCandidates','maxedQueries','conversionFailures', empty string/undefined), reason for stopping retrieving or handling the candidate records
-        // 'maxMatches' and 'maxCandidates' are in stopReason, 'maxedQueries', 'conversionFailures' and 'matchErrors' are created here
-
-        if (state.queriesLeft > 0 || nonRetrieved > 0 || state.maxedQueries.length > 0 || conversionFailureCount > 0 || matchErrorCount > 0) {
-          const maxedQueriesStopReason = state.maxedQueries.length > 0 ? 'maxedQueries' : undefined;
-          const conversionFailuresStopReason = conversionFailureCount > 0 ? 'conversionFailures' : undefined;
-          const matchErrorsStopReason = matchErrorCount > 0 ? 'matchErrors' : undefined;
-          const newStopReason = stopReason === '' || stopReason === undefined ? maxedQueriesStopReason || conversionFailuresStopReason || matchErrorsStopReason : stopReason;
+        if (state2.queriesLeft > 0 || nonRetrieved > 0 || state2.maxedQueries.length > 0 || matchErrorCount2 > 0) {
+          const maxedQueriesStopReason = state2.maxedQueries.length > 0 ? "maxedQueries" : void 0;
+          const matchErrorsStopReason = matchErrorCount2 > 0 ? "matchErrors" : void 0;
+          const newStopReason = stopReason2 === "" || stopReason2 === void 0 ? maxedQueriesStopReason || matchErrorsStopReason : stopReason2;
           debugData(`MaxedQueriesStopReason: <${maxedQueriesStopReason}>`);
-          debugData(`ConversionFailureStopReason <${conversionFailuresStopReason}>`);
           debugData(`MatchErrorsStopReason <${matchErrorsStopReason}>`);
           debugData(`NewStopReason: <${newStopReason}>`);
           debug(`Match status: false`);
-          return {
-            status: false,
-            stopReason: newStopReason
-          };
+          return { status: false, stopReason: newStopReason };
         }
         debug(`Match status: true`);
-        return {
-          status: true,
-          stopReason
-        };
+        return { status: true, stopReason: stopReason2 };
       }
     }
-
-    // NOTES:
-    // - we could optimize by creating the featureSet for the incoming record once and using it for all database/candidateRecords
-    // - if creating the featureSet for the incoming record fails we have an unprocessable entity
-    // - if creating the featureSet for a candidate record fails we could skip that candidate - but list the case as a detectionFailure, same as conversionFailures
-
-    function iterateRecords({
-      records,
-      recordSetSize,
-      maxMatches,
-      matches = [],
-      nonMatches = [],
-      recordMatches = [],
-      recordNonMatches = [],
-      recordCount = 0,
-      recordDuplicateCount = 0,
-      recordNonMatchCount = 0,
-      recordMatchErrors = []
-    }) {
-      // recordSetSize : total amount of records in the current record set
-      // recordCount : amount of records from the current record set that have been handled
-      // maxMatches : setting for maximum amount found by current matcher job before the matcher job is stopped
-      // recordDuplicateCount : amount of records from the current record set that are already included in matches/nonMatches results
-      // recordNonMatchCount: amount of records from the current record set that are nonMatches (only is returnNonMatches setting is false)
-
-      // records : non-handled records in the current record set
-      // matches : found matches in the current matcher job
-      // recordMatches : found matches in the current record set
-      // recordNonMatches : found nonMatches in the current record set (only if returnNonMatches setting is true)
-      // recordMatchErrors: errored matchDetection in the current record set
-
+    function iterateRecords({ records, recordSetSize, maxMatches: maxMatches2, matches = [], nonMatches = [], recordMatches = [], recordNonMatches = [], recordCount = 0, recordDuplicateCount = 0, recordNonMatchCount = 0, recordMatchErrors = [] }) {
       const [candidate] = records;
       const newRecordCount = candidate ? recordCount + 1 : recordCount;
-
-      // The matcher uses same matchDetection strategy for candidates from all candidate-searches -> matchDetection result for the same candidate is always same
-      // Exceptions would happen if the candidate would have been updated in the database between candidate searches
-      // Note that if returnNonMatches is false, matcher won't remember candidates that didn't match, so they will be matched again everytime they are retrieved by
-      // different candidate search queries. Same candidate search query won't have duplicate records.
-
-      /* We could optimize and detect all retrieved candidates at once
-      const candidateRecords = records.map(record => record.record);
-      const recordsIsArray = Array.isArray(candidateRecords);
-      debug(`records is an array: ${recordsIsArray}`);
-      const result = detect(record, candidateRecords);
-      debugData(`${JSON.stringify(result)}`);
-      */
-
       if (candidate) {
-        // eslint-disable-next-line functional/no-conditional-statements
         if (candidateNotInMatches(matches.concat(nonMatches), candidate)) {
-          const {
-            record: candidateRecord,
-            id: candidateId
-          } = candidate;
-          const recordBExternal = {
-            id: candidate.id,
-            recordSource: 'databaseRecord',
-            label: `db-${candidate.id}`
-          };
+          const { record: candidateRecord, id: candidateId } = candidate;
+          const recordBExternal = { id: candidate.id, recordSource: "databaseRecord", label: `db-${candidate.id}` };
           try {
             debug(`Running matchDetection for record ${candidateId} (${newRecordCount}/${recordSetSize})`);
-            // we should handle errors from detection somehow - ie. cases where either record or candidateRecord errors
-            const detectionResult = detect({
-              recordA: record,
-              recordB: candidateRecord,
-              recordAExternal: recordExternal,
-              recordBExternal
-            });
+            const detectionResult = detect({ recordA: record, recordB: candidateRecord, recordAExternal: recordExternal, recordBExternal });
             return handleDetectionResult(detectionResult, candidateId, candidateRecord);
           } catch (error) {
             debug(`MatchDetection errored: database record ${candidateId}: ${error}`);
-            const matchError = {
-              status: 422,
-              payload: {
-                message: `Matching errored for database record ${candidateId}. ${error.message}.`,
-                id: candidateId
-              }
-            };
+            const matchError = { status: 422, payload: { message: `Matching errored for database record ${candidateId}. ${error.message}.`, id: candidateId } };
             const newRecordMatchErrors = recordMatchErrors.concat(matchError);
-            return iterateRecords({
-              records: records.slice(1),
-              recordSetSize,
-              maxMatches,
-              matches,
-              recordMatches,
-              recordCount: newRecordCount,
-              recordNonMatches,
-              recordDuplicateCount,
-              recordNonMatchCount,
-              recordMatchErrors: newRecordMatchErrors
-            });
+            return iterateRecords({ records: records.slice(1), recordSetSize, maxMatches: maxMatches2, matches, recordMatches, recordCount: newRecordCount, recordNonMatches, recordDuplicateCount, recordNonMatchCount, recordMatchErrors: newRecordMatchErrors });
           }
         }
-        return iterateRecords({
-          records: records.slice(1),
-          recordSetSize,
-          maxMatches,
-          matches,
-          recordMatches,
-          recordCount: newRecordCount,
-          recordNonMatches,
-          recordDuplicateCount: recordDuplicateCount + 1,
-          recordNonMatchCount,
-          recordMatchErrors
-        });
+        return iterateRecords({ records: records.slice(1), recordSetSize, maxMatches: maxMatches2, matches, recordMatches, recordCount: newRecordCount, recordNonMatches, recordDuplicateCount: recordDuplicateCount + 1, recordNonMatchCount, recordMatchErrors });
       }
       debug(`No more candidates, record set (${recordCount}/${recordSetSize}) done, ${recordMatches.length} matches found, ${recordDuplicateCount} candidates already handled, ${returnNonMatches ? `${recordNonMatches.length}` : `${recordNonMatchCount}`} nonMatches found.`);
-      return {
-        matches: recordMatches,
-        nonMatches: returnNonMatches ? recordNonMatches : [],
-        duplicateCount: recordDuplicateCount,
-        nonMatchCount: recordNonMatchCount,
-        matchErrors: recordMatchErrors
-      };
+      return { matches: recordMatches, nonMatches: returnNonMatches ? recordNonMatches : [], duplicateCount: recordDuplicateCount, nonMatchCount: recordNonMatchCount, matchErrors: recordMatchErrors };
       function handleDetectionResult(detectionResult, candidateId, candidateRecord) {
         debugData(`MatchDetection results for ${candidateId} (${newRecordCount}/${recordSetSize}): ${JSON.stringify(detectionResult)}`);
         if (detectionResult.match || returnNonMatches) {
@@ -487,93 +156,49 @@ var _default = ({
             strategy: detectionResult.strategy,
             treshold: detectionResult.treshold
           };
-          const newMatch = returnStrategy ? {
-            ...matchResult,
-            ...strategyResult
-          } : {
-            ...matchResult
-          };
+          const newMatch = returnStrategy ? { ...matchResult, ...strategyResult } : { ...matchResult };
           debugData(`${JSON.stringify(newMatch)}`);
           return handleRecordMatch(detectionResult.match, newMatch);
         }
         const newRecordNonMatchCount = recordNonMatchCount + 1;
         debugData(`- Total nonMatches after this detection: ${newRecordNonMatchCount}`);
-        return iterateRecords({
-          records: records.slice(1),
-          recordSetSize,
-          maxMatches,
-          matches,
-          recordMatches,
-          recordCount: newRecordCount,
-          recordNonMatches,
-          recordDuplicateCount,
-          recordNonMatchCount: newRecordNonMatchCount,
-          recordMatchErrors
-        });
+        return iterateRecords({ records: records.slice(1), recordSetSize, maxMatches: maxMatches2, matches, recordMatches, recordCount: newRecordCount, recordNonMatches, recordDuplicateCount, recordNonMatchCount: newRecordNonMatchCount, recordMatchErrors });
       }
       function handleRecordMatch(isMatch, newMatch) {
         const newRecordMatches = isMatch ? recordMatches.concat(newMatch) : recordMatches;
         const newRecordNonMatches = isMatch ? recordNonMatches : recordNonMatches.concat(newMatch);
         const newRecordNonMatchCount = isMatch ? recordNonMatchCount : recordNonMatchCount + 1;
-        debugData(`- Total matches after this detection: ${matches.concat(newRecordMatches).length} (max: ${maxMatches})`);
-
-        // eslint-disable-next-line functional/no-conditional-statements
+        debugData(`- Total matches after this detection: ${matches.concat(newRecordMatches).length} (max: ${maxMatches2})`);
         if (returnNonMatches) {
           debugData(`- Total nonMatches after this detection: ${nonMatches.concat(newRecordNonMatches).length}`);
         }
         debugData(`- Total nonMatchCount after this detection: ${recordNonMatchCount}`);
-        if (maxMatchesFound({
-          matches: matches.concat(newRecordMatches),
-          maxMatches
-        })) {
-          debug(`MaxMatches (${maxMatches}) reached, handled candidates in record set: ${newRecordCount} non-handled candidates in record set ${recordSetSize - newRecordCount}`);
-          return {
-            matches: newRecordMatches,
-            nonMatches: returnNonMatches ? newRecordNonMatches : [],
-            duplicateCount: recordDuplicateCount,
-            nonMatchCount: newRecordNonMatchCount,
-            matchErrors: recordMatchErrors
-          };
+        if (maxMatchesFound({ matches: matches.concat(newRecordMatches), maxMatches: maxMatches2 })) {
+          debug(`MaxMatches (${maxMatches2}) reached, handled candidates in record set: ${newRecordCount} non-handled candidates in record set ${recordSetSize - newRecordCount}`);
+          return { matches: newRecordMatches, nonMatches: returnNonMatches ? newRecordNonMatches : [], duplicateCount: recordDuplicateCount, nonMatchCount: newRecordNonMatchCount, matchErrors: recordMatchErrors };
         }
-        return iterateRecords({
-          records: records.slice(1),
-          recordSetSize,
-          maxMatches,
-          matches,
-          recordMatches: newRecordMatches,
-          recordCount: newRecordCount,
-          recordNonMatches: returnNonMatches ? newRecordNonMatches : [],
-          duplicateCount: recordDuplicateCount,
-          recordNonMatchCount: newRecordNonMatchCount,
-          matchErrors: recordMatchErrors
-        });
+        return iterateRecords({ records: records.slice(1), recordSetSize, maxMatches: maxMatches2, matches, recordMatches: newRecordMatches, recordCount: newRecordCount, recordNonMatches: returnNonMatches ? newRecordNonMatches : [], duplicateCount: recordDuplicateCount, recordNonMatchCount: newRecordNonMatchCount, matchErrors: recordMatchErrors });
       }
-      function candidateNotInMatches(matches, candidate) {
-        debug(`Checking that record ${candidate.id} is not already included in ${matches.length} matches/nonMatches`);
-        const newCandidateId = candidate.id;
+      function candidateNotInMatches(matches2, candidate2) {
+        debug(`Checking that record ${candidate2.id} is not already included in ${matches2.length} matches/nonMatches`);
+        const newCandidateId = candidate2.id;
         debugData(`newCandidateId: ${newCandidateId}`);
-        const result = matches.find(({
-          candidate
-        }) => candidate.id === newCandidateId);
+        const result = matches2.find(({ candidate: candidate3 }) => candidate3.id === newCandidateId);
         debugData(`Result: ${result}`);
         if (result) {
-          debug(`${candidate.id} was already handled.`);
+          debug(`${candidate2.id} was already handled.`);
           return false;
         }
-        debug(`${candidate.id} not found in matches/nonMatches`);
+        debug(`${candidate2.id} not found in matches/nonMatches`);
         return true;
       }
     }
-    function maxMatchesFound({
-      matches,
-      maxMatches
-    }) {
-      if (maxMatches && matches.length >= maxMatches) {
-        debug(`Stopping recordSet iteration: maxMatches (${maxMatches}) for matcher job found.`);
+    function maxMatchesFound({ matches, maxMatches: maxMatches2 }) {
+      if (maxMatches2 && matches.length >= maxMatches2) {
+        debug(`Stopping recordSet iteration: maxMatches (${maxMatches2}) for matcher job found.`);
         return true;
       }
     }
-  };
+  }
 };
-exports.default = _default;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map