@natlibfi/melinda-record-matching 2.2.1-alpha.1 → 2.2.1-alpha.3

package/dist/index.js

@@ -0,0 +1,559 @@
+"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"));
+exports.candidateSearch = candidateSearch;
+var matchDetection = _interopRequireWildcard(require("./match-detection"));
+exports.matchDetection = matchDetection;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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');
+  debugData(`DetectionOptions: ${JSON.stringify(detectionOptions)}`);
+  debugData(`SearchOptions: ${JSON.stringify(searchOptions)}`);
+  debugData(`MaxMatches: ${JSON.stringify(maxMatches)}`);
+  debugData(`MaxCandidates: ${JSON.stringify(maxCandidates)}`);
+  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 => {
+    const search = (0, candidateSearch.default)({
+      ...searchOptions,
+      record,
+      maxCandidates
+    });
+    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 = []
+    }) {
+      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 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}`);
+      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
+        });
+      }
+      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
+      });
+      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 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
+          });
+        }
+        if (maxCandidatesRetrieved(newCandidateCount, maxCandidates)) {
+          return returnResult({
+            matches: newMatches,
+            state,
+            stopReason: 'maxCandidates',
+            nonMatches: newNonMatches,
+            duplicateCount: newDuplicateCount,
+            candidateCount: newCandidateCount,
+            nonMatchCount: newNonMatchCount,
+            conversionFailures: newConversionFailures,
+            matchErrors: newMatchErrors
+          });
+        }
+        return iterate({
+          initialState: state,
+          matches: newMatches,
+          candidateCount: newCandidateCount,
+          nonMatches: newNonMatches,
+          duplicateCount: newDuplicateCount,
+          nonMatchCount: newNonMatchCount,
+          conversionFailures: newConversionFailures,
+          matchErrors: newMatchErrors
+        });
+      }
+      function handleMatchResult(matchResult, matches, nonMatches, matchErrors) {
+        debugData(`- Amount of new matches from record set: ${matchResult.matches.length}`);
+        // eslint-disable-next-line functional/no-conditional-statement
+        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);
+        debugData(`- Total amount of matches: ${newMatches.length}`);
+        // eslint-disable-next-line functional/no-conditional-statement
+        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(`- Total amount of matchErrors: ${newMatchErrors.length}`);
+        return {
+          newMatches,
+          newNonMatches,
+          newMatchErrors
+        };
+      }
+      function addQuery(matches) {
+        debugData(`Adding query ${state.query} to matches`);
+        return matches.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`);
+          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;
+      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
+      } : {
+        matches,
+        matchStatus
+      };
+      const failures = [...conversionFailures, ...matchErrors];
+      const result = returnFailures ? {
+        ...matchesResult,
+        conversionFailures: failures
+      } : matchesResult;
+      debugData(`ReturnFailures ${returnFailures}`);
+      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;
+        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`);
+          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;
+        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;
+          debugData(`MaxedQueriesStopReason: <${maxedQueriesStopReason}>`);
+          debugData(`ConversionFailureStopReason <${conversionFailuresStopReason}>`);
+          debugData(`MatchErrorsStopReason <${matchErrorsStopReason}>`);
+          debugData(`NewStopReason: <${newStopReason}>`);
+          debug(`Match status: false`);
+          return {
+            status: false,
+            stopReason: newStopReason
+          };
+        }
+        debug(`Match status: true`);
+        return {
+          status: true,
+          stopReason
+        };
+      }
+    }
+
+    // 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
+
+    // eslint-disable-next-line max-statements
+    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
+
+      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);
+      debug(`${JSON.stringify(result)}`);
+      */
+
+      if (candidate) {
+        // eslint-disable-next-line functional/no-conditional-statement
+        if (candidateNotInMatches(matches.concat(nonMatches), candidate)) {
+          const {
+            record: candidateRecord,
+            id: candidateId
+          } = candidate;
+          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(record, candidateRecord);
+            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 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,
+          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
+      };
+      function handleDetectionResult(detectionResult, candidateId, candidateRecord) {
+        debugData(`MatchDetection results for ${candidateId} (${newRecordCount}/${recordSetSize}): ${JSON.stringify(detectionResult)}`);
+        if (detectionResult.match || returnNonMatches) {
+          debug(`${detectionResult.match ? `Record ${candidateId} (${newRecordCount}/${recordSetSize}) is a match!` : `Record ${candidateId} (${newRecordCount}/${recordSetSize}) is NOT a match!`}`);
+          debugData(`Strategy: ${JSON.stringify(detectionResult.strategy)}, Treshold: ${JSON.stringify(detectionResult.treshold)}`);
+          const matchResult = {
+            probability: detectionResult.probability,
+            candidate: {
+              id: candidateId,
+              record: candidateRecord
+            }
+          };
+          const strategyResult = {
+            strategy: detectionResult.strategy,
+            treshold: detectionResult.treshold
+          };
+          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
+        });
+      }
+      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-statement
+        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
+          };
+        }
+        return iterateRecords({
+          records: records.slice(1),
+          recordSetSize,
+          maxMatches,
+          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;
+        debugData(`newCandidateId: ${newCandidateId}`);
+        const result = matches.find(({
+          candidate
+        }) => candidate.id === newCandidateId);
+        debugData(`Result: ${result}`);
+        if (result) {
+          debug(`${candidate.id} was already handled.`);
+          return false;
+        }
+        debug(`${candidate.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.`);
+        return true;
+      }
+    }
+  };
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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