@natlibfi/melinda-record-matching 2.2.0-alpha.1 → 2.2.0-alpha.4

package/dist/matching-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/matching-utils.js"],"names":["debug","debugData","extend","getMelindaIdsF035","record","f035s","getFields","length","allF035MelindaIds","concat","map","toMelindaIds","f035MelindaIds","Set","JSON","stringify","subfields","melindaIdRegExp","filter","sub","includes","code","test","value","replace","validateSidFieldSubfieldCounts","field","countC","countSubfields","countB","subfieldCode","getSubfieldValues"],"mappings":"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","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 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';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:utils');\nconst debugData = debug.extend('data');\n\n// eslint-disable-next-line max-statements\nexport function getMelindaIdsF035(record) {\n\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:melinda-id');\n  const debugData = debug.extend('data');\n\n  const f035s = record.getFields('035');\n\n  if (f035s.length < 1) {\n    debug(`No f035s found.`);\n    return [];\n  }\n\n  const allF035MelindaIds = [].concat(...f035s.map(toMelindaIds));\n  const f035MelindaIds = [...new Set(allF035MelindaIds)];\n\n  debugData(`Fields (${f035s.length}): ${JSON.stringify(f035s)}`);\n  debugData(`Ids (${allF035MelindaIds.length}): ${JSON.stringify(allF035MelindaIds)}`);\n  debugData(`Unique ids (${f035MelindaIds.length}): ${JSON.stringify(f035MelindaIds)}`);\n\n  return f035MelindaIds;\n\n  function toMelindaIds({subfields}) {\n    const melindaIdRegExp = /^(?<prefix>\\(FI-MELINDA\\)|FCC)(?<id>\\d{9})$/u;\n\n    return subfields\n      .filter(sub => ['a', 'z'].includes(sub.code))\n      .filter(sub => melindaIdRegExp.test(sub.value))\n      .map(({value}) => value.replace(melindaIdRegExp, '$<id>'));\n\n  }\n}\n\nexport function validateSidFieldSubfieldCounts(field) {\n  // Valid SID-fields have just one $c and one $b\n  debugData(`Validating SID field ${JSON.stringify(field)}`);\n  const countC = countSubfields(field, 'c');\n  const countB = countSubfields(field, 'b');\n  debug(`Found ${countC} sf $cs and ${countB} sf $bs. IsValid: ${countC === 1 && countB === 1}`);\n\n  return countC === 1 && countB === 1;\n}\n\nfunction countSubfields(field, subfieldCode) {\n  // debug(`Counting subfields ${subfieldCode}`);\n  return field.subfields.filter(({code}) => code === subfieldCode).length;\n}\n\nexport function getSubfieldValues(field, subfieldCode) {\n  debugData(`Get subfield(s) $${subfieldCode} from ${JSON.stringify(field)}`);\n  return field.subfields.filter(({code}) => code === subfieldCode).map(({value}) => value);\n}\n\n"],"file":"matching-utils.js"}
+{"version":3,"file":"matching-utils.js","names":["debug","createDebugLogger","debugData","extend","getMelindaIdsF035","record","f035s","getFields","length","allF035MelindaIds","concat","map","toMelindaIds","f035MelindaIds","Set","JSON","stringify","subfields","melindaIdRegExp","filter","sub","includes","code","test","value","replace","validateSidFieldSubfieldCounts","field","countC","countSubfields","countB","subfieldCode","getSubfieldValues"],"sources":["../src/matching-utils.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 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';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:utils');\nconst debugData = debug.extend('data');\n\n// eslint-disable-next-line max-statements\nexport function getMelindaIdsF035(record) {\n\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:melinda-id');\n  const debugData = debug.extend('data');\n\n  const f035s = record.getFields('035');\n\n  if (f035s.length < 1) {\n    debug(`No f035s found.`);\n    return [];\n  }\n\n  const allF035MelindaIds = [].concat(...f035s.map(toMelindaIds));\n  const f035MelindaIds = [...new Set(allF035MelindaIds)];\n\n  debugData(`Fields (${f035s.length}): ${JSON.stringify(f035s)}`);\n  debugData(`Ids (${allF035MelindaIds.length}): ${JSON.stringify(allF035MelindaIds)}`);\n  debugData(`Unique ids (${f035MelindaIds.length}): ${JSON.stringify(f035MelindaIds)}`);\n\n  return f035MelindaIds;\n\n  function toMelindaIds({subfields}) {\n    const melindaIdRegExp = /^(?<prefix>\\(FI-MELINDA\\)|FCC)(?<id>\\d{9})$/u;\n\n    return subfields\n      .filter(sub => ['a', 'z'].includes(sub.code))\n      .filter(sub => melindaIdRegExp.test(sub.value))\n      .map(({value}) => value ? value.replace(melindaIdRegExp, '$<id>') : '');\n\n  }\n}\n\nexport function validateSidFieldSubfieldCounts(field) {\n  // Valid SID-fields have just one $c and one $b\n  debugData(`Validating SID field ${JSON.stringify(field)}`);\n  const countC = countSubfields(field, 'c');\n  const countB = countSubfields(field, 'b');\n  debug(`Found ${countC} sf $cs and ${countB} sf $bs. IsValid: ${countC === 1 && countB === 1}`);\n\n  return countC === 1 && countB === 1;\n}\n\nfunction countSubfields(field, subfieldCode) {\n  // debug(`Counting subfields ${subfieldCode}`);\n  return field.subfields.filter(({code}) => code === subfieldCode).length;\n}\n\nexport function getSubfieldValues(field, subfieldCode) {\n  debugData(`Get subfield(s) $${subfieldCode} from ${JSON.stringify(field)}`);\n  return field.subfields.filter(({code}) => code === subfieldCode).map(({value}) => value);\n}\n\n"],"mappings":"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"}

package/package.json

@@ -14,7 +14,7 @@
 		"url": "git@github.com:natlibfi/melinda-record-matching-js.git"
 	},
 	"license": "LGPL-3.0+",
-	"version": "2.2.0-alpha.1",
+	"version": "2.2.0-alpha.4",
 	"main": "./dist/index.js",
 	"engines": {
 		"node": ">=14"
@@ -40,20 +40,20 @@
 		"@natlibfi/melinda-commons": "^12.0.3",
 		"@natlibfi/sru-client": "^5.0.1",
 		"debug": "^4.3.4",
-		"moment": "^2.29.2",
-		"natural": "^5.1.13",
+		"moment": "^2.29.4",
+		"natural": "^5.2.3",
 		"uuid": "^8.3.2",
-		"winston": "^3.7.2"
+		"winston": "^3.8.1"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.17.6",
-		"@babel/core": "^7.17.9",
-		"@babel/eslint-parser": "^7.17.0",
-		"@babel/node": "^7.16.8",
-		"@babel/preset-env": "^7.16.11",
-		"@babel/register": "^7.17.7",
+		"@babel/cli": "^7.18.10",
+		"@babel/core": "^7.18.13",
+		"@babel/eslint-parser": "^7.18.9",
+		"@babel/node": "^7.18.10",
+		"@babel/preset-env": "^7.18.10",
+		"@babel/register": "^7.18.9",
 		"@natlibfi/eslint-config-melinda-backend": "^2.0.0",
-		"@natlibfi/fixugen": "^1.0.2",
+		"@natlibfi/fixugen": "^1.1.0",
 		"@natlibfi/fixugen-http-client": "^2.0.1",
 		"@natlibfi/fixura": "^2.2.1",
 		"babel-plugin-istanbul": "^6.1.1",
@@ -61,9 +61,9 @@
 		"chai": "^4.3.6",
 		"chai-as-promised": "^7.1.1",
 		"cross-env": "^7.0.3",
-		"eslint": "^8.13.0",
+		"eslint": "^8.23.0",
 		"mocha": "^9.2.2",
-		"nodemon": "^2.0.15",
+		"nodemon": "^2.0.19",
 		"nyc": "^15.1.0"
 	},
 	"eslintConfig": {

package/src/candidate-search/index.js

@@ -66,6 +66,9 @@ export default ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest =
 
   debug(`Searching matches for ${inputRecordId}`);
   debug(`Generated queryList ${JSON.stringify(queryList)}`);
+
+  // if generateQueryList errored we should throw 422
+
   if (queryList.length === 0) { // eslint-disable-line functional/no-conditional-statement
     throw new CandidateSearchError(`Generated query list contains no queries`);
   }
@@ -149,21 +152,21 @@ export default ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest =
               reject(err);
             }
           })
-          .on('record', foundRecordXML => {
+          .on('record', recordXML => {
             promises.push(handleRecord()); // eslint-disable-line functional/immutable-data
 
             async function handleRecord() {
               try {
-                const foundRecordMarc = await MARCXML.from(foundRecordXML, {subfieldValues: false});
-                const foundRecordId = getRecordId(foundRecordMarc);
+                const recordMarc = await MARCXML.from(recordXML, {subfieldValues: false});
+                const recordId = getRecordId(recordMarc);
 
-                return {record: foundRecordMarc, id: foundRecordId};
+                return {record: recordMarc, id: recordId};
               } catch (err) {
                 // What should this do?
-                const idFromXML = getRecordIdFromXML(foundRecordXML);
-                debugData(`Failed converting record: ${err.message}, id: ${idFromXML}, data: ${foundRecordXML}`);
-                //return {message: `Failed converting record: ${err.message}`, id: idFromXML, data: foundRecordXML};
-                throw new MatchingError(422, {message: `Failed converting record: ${err.message}`, id: idFromXML || '000000000', data: foundRecordXML});
+                const idFromXML = getRecordIdFromXML(recordXML);
+                debugData(`Failed converting record: ${err.message}, id: ${idFromXML}, data: ${recordXML}`);
+                //return {message: `Failed converting record: ${err.message}`, id: idFromXML, data: recordXML};
+                throw new MatchingError(422, {message: `Failed converting record: ${err.message}`, id: idFromXML || '000000000', data: recordXML});
               }
             }
           });

package/src/candidate-search/query-list/bib.js

@@ -108,7 +108,7 @@ export function bibSourceIds(record) {
 
         function removeSourcePrefix(subfieldValue) {
           const sourcePrefixRegex = (/^(?<sourcePrefix>\([A-Za-z0-9-]+\))(?<id>.+)$/u);
-          const normalizedValue = subfieldValue.replace(sourcePrefixRegex, '$<id>');
+          const normalizedValue = subfieldValue ? subfieldValue.replace(sourcePrefixRegex, '$<id>') : '';
           debugData(`Normalized ${subfieldValue} to ${normalizedValue}`);
           return normalizedValue;
         }
@@ -116,7 +116,7 @@ export function bibSourceIds(record) {
         function normalizeSidSubfieldValue(subfieldValue) {
           debugData(`Normalizing ${subfieldValue}`);
           const normalizeAwayRegex = (/[- ]/u);
-          return subfieldValue.replace(normalizeAwayRegex, '');
+          return subfieldValue ? subfieldValue.replace(normalizeAwayRegex, '') : '';
         }
 
       }

package/src/index.js

@@ -29,10 +29,11 @@
 import createDebugLogger from 'debug';
 import createSearchInterface, * as candidateSearch from './candidate-search';
 import createDetectionInterface, * as matchDetection from './match-detection';
+//import inspect from 'util';
 
 export {candidateSearch, matchDetection};
 
-export default ({detection: detectionOptions, search: searchOptions, maxMatches = 1, maxCandidates = 25, returnStrategy = false, returnQuery = false, returnNonMatches = false, returnFailures}) => {
+export default ({detection: detectionOptions, search: searchOptions, maxMatches = 1, maxCandidates = 25, returnStrategy = false, returnQuery = false, returnNonMatches = false, returnFailures = false}) => {
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:index');
   const debugData = debug.extend('data');
 
@@ -65,11 +66,11 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
     // 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 = []}) {
+    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}`);
+      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;
@@ -83,11 +84,11 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
 
       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});
+        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});
+      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}`);
@@ -96,20 +97,20 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
 
         const newDuplicateCount = duplicateCount + matchResult.duplicateCount;
         const newNonMatchCount = nonMatchCount + matchResult.nonMatchCount;
-        const {newMatches, newNonMatches} = handleMatchResult(matchResult, matches, nonMatches);
+        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});
+          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});
+          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});
+        return iterate({initialState: state, matches: newMatches, candidateCount: newCandidateCount, nonMatches: newNonMatches, duplicateCount: newDuplicateCount, nonMatchCount: newNonMatchCount, conversionFailures: newConversionFailures, matchErrors: newMatchErrors});
       }
 
-      function handleMatchResult(matchResult, matches, nonMatches) {
+      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) {
@@ -118,6 +119,7 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
 
         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
@@ -125,7 +127,12 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
           debugData(`- Total amount of nonMatches: ${newNonMatches.length}`);
         }
 
-        return {newMatches, newNonMatches};
+        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) {
@@ -150,6 +157,7 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
     // - 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
 
@@ -158,25 +166,27 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
     // - 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}) {
+    function returnResult({matches, state, stopReason, nonMatches, duplicateCount, candidateCount, nonMatchCount, conversionFailures, matchErrors}) {
       const conversionFailureCount = conversionFailures.length;
-      checkCounts({matches, nonMatches, candidateCount, duplicateCount, nonMatchCount, conversionFailureCount});
-      const matchStatus = getMatchState(state, stopReason, conversionFailureCount);
+      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 result = returnFailures ? {...matchesResult, conversionFailures} : matchesResult;
+      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}) {
+      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}`);
+        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`);
@@ -185,9 +195,11 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         return;
       }
 
-      function getMatchState(state, stopReason, conversionFailuresCount) {
+      // 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}>`);
@@ -197,14 +209,16 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         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' and 'conversionFailures' are created here
+        // '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) {
+        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 newStopReason = stopReason === '' || stopReason === undefined ? maxedQueriesStopReason || conversionFailuresStopReason : stopReason;
+          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};
@@ -215,7 +229,13 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
       }
     }
 
-    function iterateRecords({records, recordSetSize, maxMatches, matches = [], nonMatches = [], recordMatches = [], recordNonMatches = [], recordCount = 0, recordDuplicateCount = 0, recordNonMatchCount = 0}) {
+    // 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
@@ -227,6 +247,7 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
       // 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;
@@ -236,19 +257,39 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
       // 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;
-          debug(`Running matchDetection for record ${candidateId} (${newRecordCount}/${recordSetSize})`);
-          const detectionResult = detect(record, candidateRecord);
-          return handleDetectionResult(detectionResult, candidateId, candidateRecord);
+          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});
+
+        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};
+      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)}`);
@@ -278,7 +319,7 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         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});
+        return iterateRecords({records: records.slice(1), recordSetSize, maxMatches, matches, recordMatches, recordCount: newRecordCount, recordNonMatches, recordDuplicateCount, recordNonMatchCount: newRecordNonMatchCount, recordMatchErrors});
       }
 
       function handleRecordMatch(isMatch, newMatch) {
@@ -296,10 +337,10 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
 
         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};
+          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});
+        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) {

package/src/match-detection/features/bib/authors.js

@@ -40,7 +40,7 @@ export default ({nameTreshold = 10} = {}) => ({
 
       function toObj({code, value}) {
         if (code === 'a') {
-          return {name: value.replace(/[^\p{Letter}\p{Number}]/gu, '').toLowerCase()};
+          return {name: value ? value.replace(/[^\p{Letter}\p{Number}]/gu, '').toLowerCase() : ''};
         }
 
         return {id: value};

package/src/match-detection/features/bib/standard-identifier-factory.js

@@ -40,7 +40,8 @@ export default ({pattern, subfieldCodes}) => {
     if (field) {
       return field.subfields
         .filter(({code}) => subfieldCodes.includes(code))
-        .map(({code, value}) => ({code, value: value.replace(/-/ug, '')}));
+      //  .map(({code, value}) => ({code, value: value.replace(/-/ug, '')}));
+        .map(({code, value}) => ({code, value: value ? value.replace(/-/ug, '') : ''}));
     }
 
     return [];

package/src/match-detection/index.js

@@ -32,7 +32,6 @@ import * as features from './features';
 
 export {features};
 
-// eslint-disable-next-line max-statements
 export default ({strategy, treshold = 0.9}, returnStrategy = false) => (recordA, recordB) => {
   const minProbabilityQuantifier = 0.5;
 
@@ -44,22 +43,36 @@ export default ({strategy, treshold = 0.9}, returnStrategy = false) => (recordA,
   debugData(`ReturnStrategy: ${JSON.stringify(returnStrategy)}`);
 
   const featuresA = extractFeatures(recordA);
-  const featuresB = extractFeatures(recordB);
 
-  debugData(`Features (a): ${JSON.stringify(featuresA)}`);
-  debugData(`Features (b): ${JSON.stringify(featuresB)}`);
+  debug(`We got an array of records: ${Array.isArray(recordB)}`);
+  const recordsB = Array.isArray(recordB) ? recordB : [recordB];
+  const detectionResults = recordsB.map(record => actualDetection(featuresA, record));
 
-  const featurePairs = generateFeaturePairs();
-  const similarityVector = generateSimilarityVector();
+  return Array.isArray(recordB) ? detectionResults : detectionResults[0];
 
-  if (similarityVector.some(v => v >= minProbabilityQuantifier)) {
-    const probability = calculateprobability();
-    debug(`probability: ${probability} (Treshold: ${treshold})`);
-    return returnResult({match: probability >= treshold, probability});
+  function actualDetection(featuresA, record) {
+
+    const featuresB = extractFeatures(record);
+
+    debugData(`Features (a): ${JSON.stringify(featuresA)}`);
+    debugData(`Features (b): ${JSON.stringify(featuresB)}`);
+
+    const featurePairs = generateFeaturePairs(featuresA, featuresB);
+    const similarityVector = generateSimilarityVector(featurePairs);
+
+    if (similarityVector.some(v => v >= minProbabilityQuantifier)) {
+      const probability = calculateprobability(similarityVector);
+      debug(`probability: ${probability} (Treshold: ${treshold})`);
+      return returnResult({match: probability >= treshold, probability});
+    }
+
+    debugData(`No feature yielded minimum probability amount of points (${minProbabilityQuantifier})`);
+    return returnResult({match: false, probability: 0.0});
   }
 
-  debugData(`No feature yielded minimum probability amount of points (${minProbabilityQuantifier})`);
-  return returnResult({match: false, probability: 0.0});
+  function extractFeatures(record) {
+    return strategy.reduce((acc, {name, extract}) => acc.concat({name, value: extract(record)}), []);
+  }
 
   function returnResult(result) {
     if (returnStrategy) {
@@ -76,16 +89,12 @@ export default ({strategy, treshold = 0.9}, returnStrategy = false) => (recordA,
     return strategyNames || [];
   }
 
-  function calculateprobability() {
+  function calculateprobability(similarityVector) {
     const probability = similarityVector.reduce((acc, v) => acc + v, 0.0);
     return probability > 1.0 ? 1.0 : probability;
   }
 
-  function extractFeatures(record) {
-    return strategy.reduce((acc, {name, extract}) => acc.concat({name, value: extract(record)}), []);
-  }
-
-  function generateSimilarityVector() {
+  function generateSimilarityVector(featurePairs) {
     const compared = featurePairs.map(({name, a, b}) => {
       const {compare} = strategy.find(({name: featureName}) => name === featureName);
       const points = compare(a, b);
@@ -96,7 +105,7 @@ export default ({strategy, treshold = 0.9}, returnStrategy = false) => (recordA,
     return compared.map(({points}) => points);
   }
 
-  function generateFeaturePairs() {
+  function generateFeaturePairs(featuresA, featuresB) {
     const pairs = generatePairs();
     const missingFeatures = findMissing();
 
@@ -125,4 +134,5 @@ export default ({strategy, treshold = 0.9}, returnStrategy = false) => (recordA,
         .filter(v => pairs.some(({name}) => name === v) === false);
     }
   }
+
 };

package/src/match-detection/index.spec.js

@@ -32,6 +32,11 @@ import {expect} from 'chai';
 import {MarcRecord} from '@natlibfi/marc-record';
 import * as features from './features';
 import createDetectionInterface from '.';
+import {inspect} from 'util';
+import createDebugLogger from 'debug';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:test');
+const debugData = debug.extend('data');
 
 describe('match-detection', () => {
   generateTests({
@@ -41,16 +46,25 @@ describe('match-detection', () => {
     fixura: {
       reader: READERS.JSON
     },
-    callback: ({getFixture, options, expectedResults, enabled = true}) => {
+    callback: ({getFixture, options, expectedResults, array, enabled = true}) => {
 
       if (!enabled) {
+        debug(`*** DISABLED TEST! ***`);
         return;
       }
 
       const detect = createDetectionInterface(formatOptions());
-      const recordA = new MarcRecord(getFixture('recordA.json'));
-      const recordB = new MarcRecord(getFixture('recordB.json'));
+      const recordA = new MarcRecord(getFixture('recordA.json'), {subfieldValues: false});
+      debugData(inspect(recordA));
+
+      debug(`Our recordB is an array of records: ${array}`);
+      const recordB = array
+        ? getFixture('recordB.json').map(recordJson => new MarcRecord(recordJson, {subfieldValues: false}))
+        : new MarcRecord(getFixture('recordB.json'), {subfieldValues: false});
+      debugData(inspect(recordB));
+
       const results = detect(recordA, recordB);
+      debugData(`${JSON.stringify(results)}`);
 
       expect(results).to.eql(expectedResults);
 

package/src/matching-utils.js

@@ -59,7 +59,7 @@ export function getMelindaIdsF035(record) {
     return subfields
       .filter(sub => ['a', 'z'].includes(sub.code))
       .filter(sub => melindaIdRegExp.test(sub.value))
-      .map(({value}) => value.replace(melindaIdRegExp, '$<id>'));
+      .map(({value}) => value ? value.replace(melindaIdRegExp, '$<id>') : '');
 
   }
 }