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

package/src/cli.js

@@ -0,0 +1,177 @@
+import fs from 'fs';
+import yargs from 'yargs';
+import createMatchOperator, {candidateSearch, matchDetection} from './index.js';
+import createDebugLogger from 'debug';
+import {MarcRecord} from '@natlibfi/marc-record';
+
+cli();
+
+async function cli() {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:cli');
+  const args = yargs(process.argv.slice(2))
+    .scriptName('melinda-record-matching-js')
+    .epilog('Copyright (C) 2022-2023 University Of Helsinki (The National Library Of Finland)')
+    .usage('$0 <file> [options] and env variable info in README')
+    .usage('Installed globally: $0 <file> [options] and env variable info in README')
+    .usage('Not installed: npx $0 <file> [options] and env variable info in README')
+    .usage('Build from source: node dist/index.js <file> [options] and env variable info in README')
+    .showHelpOnFail(true)
+    .example([['$ node /dist/cli.js record.json']])
+    .env('MELINDA_RECORD_MATCH')
+    .version()
+    .positional('file', {type: 'string', describe: 'Json file of records to match'})
+    .options({
+      t: {type: 'string', default: 'IDS', alias: 'searchType', describe: 'IDS, STANDARD_IDS, COMPONENT, CONTENT or CONTENTALT'},
+      m: {type: 'number', default: 1, alias: 'maxMatches', describe: ''},
+      c: {type: 'number', default: 1000, alias: 'maxCandidates', describe: ''},
+      s: {type: 'boolean', default: false, alias: 'returnStrategy', describe: ''},
+      q: {type: 'boolean', default: false, alias: 'returnQuery', describe: ''},
+      n: {type: 'boolean', default: false, alias: 'returnNonMatches', describe: ''}
+    })
+    .check((args) => {
+      const [file] = args._;
+      if (file === undefined) {
+        throw new Error('No file argument given');
+      }
+
+      if (!fs.existsSync(file)) {
+        throw new Error(`File ${file} does not exist`);
+      }
+
+      if (args.sruUrl === undefined) {
+        throw new Error('Setup sru url');
+      }
+
+      if (!['IDS', 'STANDARD_IDS', 'COMPONENT', 'CONTENT', 'CONTENTALT'].includes(args.searchType)) {
+        throw new Error('Invalid search type');
+      }
+
+      return true;
+    })
+    .parseSync();
+
+  const [file] = args._;
+  const {searchType} = args;
+  debug(JSON.stringify(args));
+
+  const detection = {
+    treshold: 0.9,
+    strategy: generateStrategy(searchType)
+  };
+
+  const search = {
+    url: args.sruUrl, searchSpec: generateSearchSpec(searchType)
+  };
+
+  const matchOperator = await createMatchOperator({detection, search, ...args});
+
+  const fileRaw = fs.readFileSync(file, 'utf8');
+  const record = new MarcRecord(JSON.parse(fileRaw), {subfieldValues: false});
+
+  const result = await matchOperator({record});
+  debug(JSON.stringify(result));
+
+
+  function generateStrategy(searchType) {
+    if (['IDS'].includes(searchType)) {
+      return [
+        matchDetection.features.bib.melindaId(),
+        matchDetection.features.bib.allSourceIds()
+      ];
+    }
+
+    // We could have differing strategy for STANDARD_IDS
+    // Let's not run title in strategy when we found the candidates through standard_ids search
+
+    if (['STANDARD_IDS'].includes(searchType)) {
+      return [
+        matchDetection.features.bib.hostComponent(),
+        matchDetection.features.bib.isbn(),
+        matchDetection.features.bib.issn(),
+        matchDetection.features.bib.otherStandardIdentifier(),
+        // Let's not use the same title matchDetection here
+        //matchDetection.features.bib.title(),
+        matchDetection.features.bib.authors(),
+        // We probably should have some leeway here for notated music as BK etc.
+        matchDetection.features.bib.recordType(),
+        // Use publicationTimeAllowConsYearsMulti to
+        //  - ignore one year differences in publicationTime
+        //  - extract publicationTimes from f008, f26x and reprint notes in f500
+        //  - do not substract points for mismatching (normal) publicationTime, if there's a match between
+        //       normal publicationTime and a reprintPublication time
+        matchDetection.features.bib.publicationTimeAllowConsYearsMulti(),
+        matchDetection.features.bib.language(),
+        matchDetection.features.bib.bibliographicLevel()
+      ];
+    }
+
+    if (['COMPONENT'].includes(searchType)) {
+      return [
+        matchDetection.features.bib.hostComponent(),
+        matchDetection.features.bib.otherStandardIdentifier(),
+        matchDetection.features.bib.recordType(),
+        matchDetection.features.bib.title(),
+        matchDetection.features.bib.language(),
+        matchDetection.features.bib.authors(),
+        matchDetection.features.bib.bibliographicLevel()
+      ];
+    }
+
+    if (['CONTENT', 'CONTENTALT'].includes(searchType)) {
+      return [
+        matchDetection.features.bib.hostComponent(),
+        matchDetection.features.bib.isbn(),
+        matchDetection.features.bib.issn(),
+        matchDetection.features.bib.otherStandardIdentifier(),
+        matchDetection.features.bib.title(),
+        matchDetection.features.bib.authors(),
+        matchDetection.features.bib.recordType(),
+        matchDetection.features.bib.publicationTime(),
+        matchDetection.features.bib.language(),
+        matchDetection.features.bib.bibliographicLevel()
+      ];
+    }
+
+    throw new Error('Unsupported match validation package');
+  }
+
+
+  function generateSearchSpec(searchType) {
+    if (['IDS'].includes(searchType)) {
+      return [
+        candidateSearch.searchTypes.bib.melindaId,
+        candidateSearch.searchTypes.bib.sourceIds
+      ];
+    }
+
+    if (['STANDARD_IDS'].includes(searchType)) {
+      return [candidateSearch.searchTypes.bib.standardIdentifiers];
+    }
+
+    if (['COMPONENT'].includes(searchType)) {
+      return [
+        //candidateSearch.searchTypes.bib.sourceIds,
+        candidateSearch.searchTypes.component.hostIdMelinda,
+        candidateSearch.searchTypes.component.hostIdOtherSource
+      ];
+    }
+
+    if (['CONTENT'].includes(searchType)) {
+      return [
+        candidateSearch.searchTypes.bib.hostComponents,
+        //candidateSearch.searchTypes.bib.titleAuthor,
+        candidateSearch.searchTypes.bib.title
+      ];
+    }
+    if (['CONTENTALT'].includes(searchType)) {
+      return [
+        candidateSearch.searchTypes.bib.hostComponents,
+        // titleAuthorYearAlternates searches for matchCandidates
+        // with alternate queries, starting from more tight searches
+        candidateSearch.searchTypes.bib.titleAuthorYearAlternates
+      ];
+    }
+
+    throw new Error('Unsupported match validation package');
+  }
+}

package/src/index.js

@@ -1,39 +1,11 @@
-/**
-*
-* @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 createDebugLogger from 'debug';
-import createSearchInterface, * as candidateSearch from './candidate-search';
-import createDetectionInterface, * as matchDetection from './match-detection';
+import createSearchInterface, * as candidateSearch from './candidate-search/index.js';
+import createDetectionInterface, * as matchDetection from './match-detection/index.js';
 //import inspect from 'util';
 
 export {candidateSearch, matchDetection};
 
-export default ({detection: detectionOptions, search: searchOptions, maxMatches = 1, maxCandidates = 25, returnStrategy = false, returnQuery = false, returnNonMatches = false, returnFailures = false}) => {
+export default ({detection: detectionOptions, search: searchOptions, maxMatches = 1, maxCandidates = 25, returnStrategy = false, returnQuery = false, returnNonMatches = false}) => {
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:index');
   const debugData = debug.extend('data');
 
@@ -44,14 +16,15 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
   debugData(`ReturnStrategy: ${JSON.stringify(returnStrategy)}`);
   debugData(`ReturnQuery: ${JSON.stringify(returnQuery)}`);
   debugData(`ReturnNonMatches: ${JSON.stringify(returnNonMatches)}`);
-  debugData(`ReturnFailures: ${JSON.stringify(returnFailures)}`);
 
 
   const detect = createDetectionInterface(detectionOptions, returnStrategy);
 
-  return ({record, recordExternal = {recordSource: 'incomingRecord', label: 'ic'}}) => {
+  return prepareSearch;
+
+  async function prepareSearch({record, recordExternal = {recordSource: 'incomingRecord', label: 'ic'}}) {
 
-    const search = createSearchInterface({...searchOptions, record, maxCandidates, recordExternal});
+    const {search} = await createSearchInterface({...searchOptions, record, maxCandidates, recordExternal});
     return iterate({});
 
     // candidateCount : amount of candidate records retrived from SRU for matching, NOT including current record set
@@ -67,17 +40,14 @@ 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 = [], matchErrors = []}) {
+    async function iterate({initialState = {}, matches = [], candidateCount = 0, nonMatches = [], duplicateCount = 0, nonMatchCount = 0, matchErrors = []}) {
       debugData(`Starting next matcher iteration.`);
-      const {records, failures, ...state} = await search(initialState);
+      const {records, ...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}`);
+      debugData(`Current state: ${JSON.stringify(state)}, matches: ${matches.length}, candidateCount: ${candidateCount}, nonMatches: ${nonMatches.length}, nonMatchCount: ${nonMatchCount}, matchErrors: ${matchErrors.length}`);
       const recordSetSize = records.length;
-      const failureSetSize = failures.length;
-      const newCandidateCount = candidateCount + recordSetSize + failureSetSize;
+      const newCandidateCount = candidateCount + recordSetSize;
 
-      const newConversionFailures = conversionFailures.concat(failures);
-      debugData(`Failures: ${failures.length}, ConversionFailures: ${conversionFailures.length}, NewConversionFailures: ${newConversionFailures.length}`);
 
       if (recordSetSize > 0) {
         return handleRecordSet();
@@ -85,11 +55,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, matchErrors});
+        return iterate({initialState: state, matches, candidateCount: newCandidateCount, nonMatches, nonMatchCount, duplicateCount, matchErrors});
       }
 
       debug(`No (more) candidate records to check, no more queries left, matches: ${matches.length}`);
-      return returnResult({matches, state, stopReason: '', nonMatches, nonMatchCount, candidateCount: newCandidateCount, duplicateCount, conversionFailures: newConversionFailures, matchErrors});
+      return returnResult({matches, state, stopReason: '', nonMatches, nonMatchCount, candidateCount: newCandidateCount, duplicateCount, matchErrors});
 
       function handleRecordSet() {
         debug(`Checking record set of ${recordSetSize} candidate records for possible matches, found by ${state.searchCounter} search for ${state.query}`);
@@ -101,19 +71,18 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         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});
+          return returnResult({matches: newMatches, state, stopReason: 'maxMatches', nonMatches: newNonMatches, duplicateCount: newDuplicateCount, candidateCount: newCandidateCount, nonMatchCount: newNonMatchCount, matchErrors: newMatchErrors});
         }
 
         if (maxCandidatesRetrieved(newCandidateCount, maxCandidates)) {
-          return returnResult({matches: newMatches, state, stopReason: 'maxCandidates', nonMatches: newNonMatches, duplicateCount: newDuplicateCount, candidateCount: newCandidateCount, nonMatchCount: newNonMatchCount, conversionFailures: newConversionFailures, matchErrors: newMatchErrors});
+          return returnResult({matches: newMatches, state, stopReason: 'maxCandidates', nonMatches: newNonMatches, duplicateCount: newDuplicateCount, candidateCount: newCandidateCount, nonMatchCount: newNonMatchCount, matchErrors: newMatchErrors});
         }
 
-        return iterate({initialState: state, matches: newMatches, candidateCount: newCandidateCount, nonMatches: newNonMatches, duplicateCount: newDuplicateCount, nonMatchCount: newNonMatchCount, conversionFailures: newConversionFailures, matchErrors: newMatchErrors});
+        return iterate({initialState: state, matches: newMatches, candidateCount: newCandidateCount, nonMatches: newNonMatches, duplicateCount: newDuplicateCount, nonMatchCount: newNonMatchCount, matchErrors: newMatchErrors});
       }
 
       function handleMatchResult(matchResult, matches, nonMatches, matchErrors) {
         debugData(`- Amount of new matches from record set: ${matchResult.matches.length}`);
-        // eslint-disable-next-line functional/no-conditional-statements
         if (returnNonMatches) {
           debugData(`- Amount of new nonMatches from record set: ${matchResult.nonMatches.length}`);
         }
@@ -123,7 +92,6 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         const newMatchErrors = matchErrors.concat(matchResult.matchErrors);
 
         debugData(`- Total amount of matches: ${newMatches.length}`);
-        // eslint-disable-next-line functional/no-conditional-statements
         if (returnNonMatches) {
           debugData(`- Total amount of nonMatches: ${newNonMatches.length}`);
         }
@@ -167,27 +135,24 @@ 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, matchErrors}) {
-      const conversionFailureCount = conversionFailures.length;
+    function returnResult({matches, state, stopReason, nonMatches, duplicateCount, candidateCount, nonMatchCount, matchErrors}) {
       const matchErrorCount = matchErrors.length;
-      checkCounts({matches, nonMatches, candidateCount, duplicateCount, nonMatchCount, conversionFailureCount, matchErrorCount});
-      const matchStatus = getMatchState(state, stopReason, conversionFailureCount, matchErrorCount);
+      checkCounts({matches, nonMatches, candidateCount, duplicateCount, nonMatchCount, matchErrorCount});
+      const matchStatus = getMatchState(state, stopReason, matchErrorCount);
       // add nonMatches to result only if returnNonMatches is 'true', otherwise nonMatches have not been gathered
       const matchesResult = returnNonMatches ? {matches, matchStatus, nonMatches, candidateCount} : {matches, matchStatus, candidateCount};
-      const failures = [...conversionFailures, ...matchErrors];
-      const result = returnFailures ? {...matchesResult, conversionFailures: failures} : matchesResult;
-      debugData(`ReturnFailures ${returnFailures}`);
+      const result = matchesResult;
       debugData(`${JSON.stringify(result)}`);
       return result;
 
       // note that in cases where the matching has been stopped because of maxMatches checkCounts won't (in most cases) match
 
-      function checkCounts({matches, nonMatches, candidateCount, duplicateCount, nonMatchCount, conversionFailureCount, matchErrorCount}) {
+      function checkCounts({matches, nonMatches, candidateCount, duplicateCount, nonMatchCount, 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(`candidateCount: ${candidateCount}, matches: ${matchCount}, nonMatches: ${chosenNonMatchCount}, duplicateCount: ${duplicateCount}, matchErrorCount: ${matchErrorCount}`);
         debug(`We got result for ${totalHandled} / ${candidateCount} retrieved candidates`);
         if (totalHandled !== candidateCount) {
           debug(`WARNING: Missing results for ${candidateCount - totalHandled} candidates`);
@@ -197,9 +162,8 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
       }
 
       // eslint-disable-next-line max-statements
-      function getMatchState(state, stopReason, conversionFailuresCount, matchErrorCount) {
+      function getMatchState(state, stopReason, 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}`);
 
@@ -209,16 +173,14 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         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
+        // matchStatus.stopReason: string ('maxMatches','maxCandidates','maxedQueries', 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) {
+        if (state.queriesLeft > 0 || nonRetrieved > 0 || state.maxedQueries.length > 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;
+          const newStopReason = stopReason === '' || stopReason === undefined ? maxedQueriesStopReason || matchErrorsStopReason : stopReason;
           debugData(`MaxedQueriesStopReason: <${maxedQueriesStopReason}>`);
-          debugData(`ConversionFailureStopReason <${conversionFailuresStopReason}>`);
           debugData(`MatchErrorsStopReason <${matchErrorsStopReason}>`);
           debugData(`NewStopReason: <${newStopReason}>`);
           debug(`Match status: false`);
@@ -266,8 +228,6 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
       */
 
       if (candidate) {
-
-        // eslint-disable-next-line functional/no-conditional-statements
         if (candidateNotInMatches(matches.concat(nonMatches), candidate)) {
           const {record: candidateRecord, id: candidateId} = candidate;
           const recordBExternal = {id: candidate.id, recordSource: 'databaseRecord', label: `db-${candidate.id}`};
@@ -330,7 +290,6 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
 
         debugData(`- Total matches after this detection: ${matches.concat(newRecordMatches).length} (max: ${maxMatches})`);
 
-        // eslint-disable-next-line functional/no-conditional-statements
         if (returnNonMatches) {
           debugData(`- Total nonMatches after this detection: ${nonMatches.concat(newRecordNonMatches).length}`);
         }
@@ -365,5 +324,5 @@ export default ({detection: detectionOptions, search: searchOptions, maxMatches
         return true;
       }
     }
-  };
+  }
 };

package/src/{index.spec.js → index.test.js}

@@ -1,37 +1,10 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020-2023 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 {expect} from 'chai';
+import assert from 'node:assert';
+import {describe} from 'node:test';
+import createDebugLogger from 'debug';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen-http-client';
 import {MarcRecord} from '@natlibfi/marc-record';
-import createMatchInterface, {matchDetection} from '.';
-import createDebugLogger from 'debug';
+import createMatchInterface, {matchDetection} from './index.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:index:test');
 const debugData = debug.extend('data');
@@ -39,7 +12,7 @@ const debugData = debug.extend('data');
 describe('INDEX', () => {
   generateTests({
     callback,
-    path: [__dirname, '..', 'test-fixtures', 'index'],
+    path: [import.meta.dirname, '..', 'test-fixtures', 'index'],
     recurse: false,
     fixura: {
       reader: READERS.JSON
@@ -58,19 +31,18 @@ describe('INDEX', () => {
     const {matches, matchStatus, nonMatches, conversionFailures, candidateCount} = await match({record});
     debugData(`Matches: ${matches.length}, Status: ${matchStatus.status}/${matchStatus.stopReason}, NonMatches: ${nonMatches ? nonMatches.length : 'not returned'}, ConversionFailures: ${conversionFailures ? conversionFailures.length : 'not returned'}`);
 
-    expect(matchStatus.status).to.eql(expectedMatchStatus);
-    expect(matchStatus.stopReason).to.eql(expectedStopReason);
-    expect(candidateCount).to.eql(expectedCandidateCount);
+    assert.equal(matchStatus.status, expectedMatchStatus);
+    assert.equal(matchStatus.stopReason, expectedStopReason);
+    assert.equal(candidateCount, expectedCandidateCount);
 
     const formattedMatchResult = formatRecordResults(matches);
-    expect(formattedMatchResult).to.eql(expectedMatches);
+    assert.deepStrictEqual(formattedMatchResult, expectedMatches);
 
     const formattedNonMatchResult = formatRecordResults(nonMatches);
-    expect(formattedNonMatchResult).to.eql(expectedNonMatches);
+    assert.deepStrictEqual(formattedNonMatchResult, expectedNonMatches);
 
-    // eslint-disable-next-line functional/no-conditional-statements
     if (expectedFailures) {
-      expect(conversionFailures).to.eql(expectedFailures);
+      assert.deepStrictEqual(conversionFailures, expectedFailures);
     }
 
     function formatOptions() {
@@ -108,8 +80,5 @@ describe('INDEX', () => {
         record: newRecord.toObject()
       };
     }
-
-
   }
-
 });

package/src/match-detection/features/bib/all-source-ids.js

@@ -1,33 +1,6 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020 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 createDebugLogger from 'debug';
-import {validateSidFieldSubfieldCounts, getSubfieldValues} from '../../../matching-utils';
+import {validateSidFieldSubfieldCounts, getSubfieldValues} from '../../../matching-utils.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:match-detection:features:all-source-ids');
 const debugData = debug.extend('data');
@@ -98,7 +71,7 @@ export default () => ({
     debugData(`Comparing ${JSON.stringify(a)} and ${JSON.stringify(b)}`);
 
     const matches = a.filter(sidA => b.some(sidB => sidA.sourceDb === sidB.sourceDb &&
-            sidA.sourceId === sidB.sourceId));
+      sidA.sourceId === sidB.sourceId));
     debugData(`Matches (${matches.length}): ${JSON.stringify(matches)}`);
 
     const mismatches = a.filter(sidA => b.some(sidB => sidA.sourceDb === sidB.sourceDb &&

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

@@ -1,33 +1,8 @@
-/**
-*
-* @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 {LevenshteinDistance as leven} from 'natural';
-import {testStringOrNumber} from '../../../matching-utils';
+
+
+import naturalPkg from 'natural';
+const {LevenshteinDistance: leven} = naturalPkg;
+import {testStringOrNumber} from '../../../matching-utils.js';
 
 // We should extract also organisational authors (110/710)
 

package/src/match-detection/features/bib/bibliographic-level.js

@@ -1,30 +1,3 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020 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.
-*
-*/
 
 export default () => ({
   name: 'Bibliographic level',

package/src/match-detection/features/bib/host-component.js

@@ -1,30 +1,3 @@
-/**
-*
-* @licstart  The following is the entire license notice for the JavaScript code in this file.
-*
-* Melinda record matching modules for Javascript
-*
-* Copyright (C) 2020 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.
-*
-*/
 
 export default () => ({
   name: 'Host/Component record',