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

package/src/candidate-search/index.js

@@ -1,45 +1,17 @@
-/**
-*
-* @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 createClient, {SruSearchError} from '@natlibfi/sru-client';
 import {MarcRecord} from '@natlibfi/marc-record';
-import {MARCXML} from '@natlibfi/marc-record-serializers';
-import generateQueryList from './query-list';
-import {Error as MatchingError} from '@natlibfi/melinda-commons';
 
-export {searchTypes} from './query-list';
+import generateQueryList from './query-list/index.js';
+import chooseQueries from './choose-queries.js';
+
+export {searchTypes} from './query-list/index.js';
 
-export class CandidateSearchError extends Error {}
+export class CandidateSearchError extends Error { }
 
 // serverMaxResults : maximum size of total search result available from the server, defaults to Aleph's 20000
 
-export default ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest = 50, serverMaxResult = 20000}) => {
+export default async ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest = 50, serverMaxResult = 20000}) => {
   MarcRecord.setValidationOptions({subfieldValues: false});
 
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search');
@@ -54,25 +26,43 @@ export default ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest =
   // Do not retrieve more candidates than defined in maxCandidates
   const adjustedMaxRecordsPerRequest = maxRecordsPerRequest >= maxCandidates ? maxCandidates : maxRecordsPerRequest;
 
-  const inputRecordId = getRecordId(record);
-  const queryList = generateQueryList(record, searchSpec);
   const client = createClient({
     url,
     maxRecordsPerRequest: adjustedMaxRecordsPerRequest,
     version: '2.0',
-    retrieveAll: false
+    retrieveAll: false,
+    metadataFormat: 'marcJson'
   });
 
-  debug(`Searching matches for ${inputRecordId}`);
-  debug(`Generated queryList ${JSON.stringify(queryList)}`);
-
+  const inputRecordId = getRecordId(record);
+  const queryListResult = await generateQueryList(record, searchSpec, client);
+  const queryList = queryListResult[0]?.queryList ? queryListResult[0].queryList : queryListResult;
+  const queryListType = queryListResult[0]?.queryListType ? queryListResult[0].queryListType : undefined;
 
   // if generateQueryList errored we should throw 422
-
   if (queryList.length === 0) {
+    debug(`Empty list`);
     throw new CandidateSearchError(`Generated query list contains no queries`);
   }
+  if (queryListType && queryListType !== 'alternates') {
+    debug(`Unknown queryListType`);
+    throw new CandidateSearchError(`Generated query list has invalid type`);
+  }
+
+  debug(`Searching matches for ${inputRecordId}`);
+  const chosenQueryList = await filterQueryList({queryList, queryListType});
+  debug(`Chosen queries: ${JSON.stringify(chosenQueryList)}`);
+
+  async function filterQueryList({queryList, queryListType, maxCandidates}) {
+    debug(`Generated queryList (type: ${queryListType}) ${JSON.stringify(queryList)}`);
 
+    if (queryListType === 'alternates' && queryList.length > 1) {
+      const queryListResult = await chooseQueries({url, queryList, queryListType, maxCandidates});
+      debug(`queryListResult: ${JSON.stringify(queryListResult)}`);
+      return queryListResult.map(elem => elem.query);
+    }
+    return queryList;
+  }
   // 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)
@@ -81,98 +71,38 @@ export default ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest =
   // state.queryCounter : sequence for current query
   // state.maxedQueries : queries that resulted in more than serverMaxResults hits
 
+  return {search};
 
-  return async ({queryOffset = 0, resultSetOffset = 1, totalRecords = 0, searchCounter = 0, queryCandidateCounter = 0, queryCounter = 0, maxedQueries = []}) => {
-    const query = queryList[queryOffset];
+  // eslint-disable-next-line max-statements
+  async function search({queryOffset = 0, resultSetOffset = 1, totalRecords = 0, searchCounter = 0, queryCandidateCounter = 0, queryCounter = 0, maxedQueries = []}) {
+    const query = chosenQueryList[queryOffset];
+    debug(`Running query ${JSON.stringify(query)} (${queryOffset})`);
 
     if (query) {
-      const {records, failures, nextOffset, total} = await retrieveRecords();
+      const {records, nextOffset, total} = await retrieveRecords(client, query, resultSetOffset);
 
       // If resultSetOffset === 1 this is the first search for the current query
       debugData(`ResultSetOffset: ${resultSetOffset}`);
       const newTotalRecords = resultSetOffset === 1 ? total : totalRecords;
       const newQueryCounter = resultSetOffset === 1 ? queryCounter + 1 : queryCounter;
       const newSearchCounter = resultSetOffset === 1 ? 1 : searchCounter + 1;
-      const newQueryCandidateCounter = resultSetOffset === 1 ? records.length + failures.length : queryCandidateCounter + records.length + failures.length;
+      const newQueryCandidateCounter = resultSetOffset === 1 ? records.length : queryCandidateCounter + records.length;
 
       const maxedQuery = resultSetOffset === 1 ? checkMaxedQuery(query, total, serverMaxResult) : undefined;
       const newMaxedQueries = maxedQuery ? maxedQueries.concat(maxedQuery) : maxedQueries;
 
       if (typeof nextOffset === 'number') {
         debug(`Next search will be for query ${queryOffset} ${query}, starting from record ${nextOffset}`);
-        return {records, failures, queryOffset, resultSetOffset: nextOffset, queriesLeft: queryList.length - (queryOffset + 1), totalRecords: newTotalRecords, query, searchCounter: newSearchCounter, queryCandidateCounter: newQueryCandidateCounter, queryCounter: newQueryCounter, maxedQueries: newMaxedQueries};
+        return {records, queryOffset, resultSetOffset: nextOffset, queriesLeft: queryList.length - (queryOffset + 1), totalRecords: newTotalRecords, query, searchCounter: newSearchCounter, queryCandidateCounter: newQueryCandidateCounter, queryCounter: newQueryCounter, maxedQueries: newMaxedQueries};
       }
       debug(`Query ${queryOffset} ${query} done.`);
       debug(`There are (${queryList.length - (queryOffset + 1)} queries left)`);
-      return {records, failures, queryOffset: queryOffset + 1, queriesLeft: queryList.length - (queryOffset + 1), totalRecords: newTotalRecords, query, searchCounter: newSearchCounter, queryCandidateCounter: newQueryCandidateCounter, queryCounter: newQueryCounter, maxedQueries: newMaxedQueries};
+      return {records, queryOffset: queryOffset + 1, queriesLeft: queryList.length - (queryOffset + 1), totalRecords: newTotalRecords, query, searchCounter: newSearchCounter, queryCandidateCounter: newQueryCandidateCounter, queryCounter: newQueryCounter, maxedQueries: newMaxedQueries};
     }
 
     debug(`All ${queryList.length} queries done, there's no query for ${queryOffset}`);
-    return {records: [], failures: [], queriesLeft: 0, queryCounter, maxedQueries};
-
-    function retrieveRecords() {
-      return new Promise((resolve, reject) => {
-        const promises = [];
-        // eslint-disable-next-line functional/no-let
-        let totalRecords = 0;
-
-        debug(`Searching for candidates with query: ${query} (Offset ${resultSetOffset})`);
-
-        client.searchRetrieve(query, {startRecord: resultSetOffset})
-          .on('error', err => {
-            // eslint-disable-next-line functional/no-conditional-statements
-            if (err instanceof SruSearchError) {
-              debug(`SRU SruSearchError for query: ${query}: ${err}`);
-              reject(new CandidateSearchError(`SRU SruSearchError for query: ${query}: ${err}`));
-            }
-            debug(`SRU error for query: ${query}: ${err}`);
-            reject(new CandidateSearchError(`SRU error for query: ${query}: ${err}`));
-          })
-          .on('total', total => {
-            debug(`Got total: ${total}`);
-            totalRecords += total;
-          })
-          .on('end', async nextOffset => {
-            try {
-              const recordPromises = await Promise.allSettled(promises);
-              debugData(`All recordPromises: ${JSON.stringify(recordPromises)}`);
-              const filtered = recordPromises.filter(r => r.status === 'fulfilled').map(r => r.value);
-              const failures = recordPromises.filter(r => r.status === 'rejected').map(r => ({status: r.reason.status, payload: r.reason.payload}));
-
-              debug(`Found ${recordPromises.length} records`);
-              debug(`Found ${filtered.length} convertable candidates`);
-              debug(`Found ${failures.length} NON-convertable candidates`);
-              debugData(`Converted: ${JSON.stringify(filtered)}.`);
-              debugData(`Not converted: ${JSON.stringify(failures)}.`);
-
-
-              resolve({nextOffset, records: filtered, failures, total: totalRecords});
-            } catch (err) {
-              debug(`Error caught on END`);
-              reject(err);
-            }
-          })
-          .on('record', recordXML => {
-            promises.push(handleRecord()); // eslint-disable-line functional/immutable-data
-
-            async function handleRecord() {
-              try {
-                const recordMarc = await MARCXML.from(recordXML, {subfieldValues: false});
-                const recordId = getRecordId(recordMarc);
-
-                return {record: recordMarc, id: recordId};
-              } catch (err) {
-                // What should this do?
-                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});
-              }
-            }
-          });
-      });
-    }
-  };
+    return {records: [], queriesLeft: 0, queryCounter, maxedQueries};
+  }
 
   function checkMaxedQuery(query, total, serverMaxResult) {
     if (total >= serverMaxResult) {
@@ -181,16 +111,52 @@ export default ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest =
     }
   }
 
-
   function getRecordId(record) {
     const [field] = record.get(/^001$/u);
     return field ? field.value : '';
   }
+};
 
-  function getRecordIdFromXML(recordXML) {
-    //<controlfield tag=\"001\">015376846</controlfield
-    debug(`Cannot yet find possible database record id from recordXML (length ${recordXML.length})`);
-    return undefined;
-  }
+export function retrieveRecords(client, query, resultSetOffset) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:retrieveRecords');
+  // eslint-disable-next-line no-unused-vars
+  const debugData = debug.extend('data');
 
-};
+  return new Promise((resolve, reject) => {
+    const records = [];
+    let totalRecords = 0;
+
+    debug(`Searching for candidates with query: ${query} (Offset ${resultSetOffset})`);
+
+    client.searchRetrieve(query, {startRecord: resultSetOffset})
+      .on('error', err => {
+        if (err instanceof SruSearchError) {
+          debug(`SRU SruSearchError for query: ${query}: ${err}`);
+          reject(new CandidateSearchError(`SRU SruSearchError for query: ${query}: ${err}`));
+        }
+
+        debug(`SRU error for query: ${query}: ${err}`);
+        reject(new CandidateSearchError(`SRU error for query: ${query}: ${err}`));
+      })
+      .on('total', total => {
+        debug(`Got total: ${total}`);
+        totalRecords += total;
+      })
+      .on('end', nextOffset => {
+        try {
+          debug(`Found ${records.length} records`);
+
+          resolve({nextOffset, records, total: totalRecords});
+        } catch (err) {
+          debug(`Error caught on END`);
+          reject(err);
+        }
+      })
+      .on('record', record => {
+        const [field] = record.get(/^001$/u);
+        debug(field);
+        const id = field.value ? field.value : '';
+        records.push({record, id});
+      });
+  });
+}

package/src/candidate-search/{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-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 {expect} from 'chai';
+import assert from 'node:assert';
+import {describe} from 'node:test';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen-http-client';
 import {MarcRecord} from '@natlibfi/marc-record';
 import {Error as MatchingError} from '@natlibfi/melinda-commons';
-import createSearchInterface, {CandidateSearchError} from '.';
+import createSearchInterface, {CandidateSearchError} from './index.js';
 import createDebugLogger from 'debug';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:test');
@@ -39,13 +12,14 @@ const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-sea
 describe('candidate-search', () => {
   generateTests({
     callback,
-    path: [__dirname, '..', '..', 'test-fixtures', 'candidate-search', 'index'],
+    path: [import.meta.dirname, '..', '..', 'test-fixtures', 'candidate-search', 'index'],
     recurse: false,
     fixura: {
       reader: READERS.JSON
     }
   });
 
+  // eslint-disable-next-line max-statements
   async function callback({getFixture, factoryOptions, searchOptions, expectedFactoryError = false, expectedSearchError = false, enabled = true}) {
     const url = 'http://foo.bar';
 
@@ -54,16 +28,31 @@ describe('candidate-search', () => {
     }
 
     if (expectedFactoryError) {
+      debug(`We're expecting an error`);
       if (expectedFactoryError.isCandidateSearchError) {
-        expect(() => createSearchInterface({...formatFactoryOptions(), url})).to.throw(CandidateSearchError, new RegExp(expectedFactoryError, 'u'));
-        return;
+        try {
+          const result = await createSearchInterface({...formatFactoryOptions(), url});
+          debug(result);
+        } catch (err) {
+          assert.equal(err instanceof CandidateSearchError, true);
+          assert.match(err.message, new RegExp(expectedFactoryError.message));
+        } finally {
+          return;
+        }
       }
 
-      expect(() => createSearchInterface({...formatFactoryOptions(), url})).to.throw(new RegExp(expectedFactoryError, 'u'));
-      return;
+      try {
+        const result = await createSearchInterface({...formatFactoryOptions(), url});
+        debug(result);
+      } catch (err) {
+        assert.equal(err instanceof Error, true);
+        assert.match(err.message, new RegExp(expectedFactoryError.message));
+      } finally {
+        return;
+      }
     }
 
-    const search = createSearchInterface({...formatFactoryOptions(), url});
+    const {search} = await createSearchInterface({...formatFactoryOptions(), url});
     await iterate({searchOptions, expectedSearchError});
 
     function formatFactoryOptions() {
@@ -79,30 +68,29 @@ describe('candidate-search', () => {
     async function iterate({searchOptions, expectedSearchError, expectedErrorStatus, count = 1}) {
       const expectedResults = getFixture(`expectedResults${count}.json`);
 
-      if (expectedSearchError) { // eslint-disable-line functional/no-conditional-statements
+      if (expectedSearchError) {
         try {
           await search(searchOptions);
           throw new Error('Expected an error');
         } catch (err) {
           debug(`Got an error: ${err}`);
-          expect(err).to.be.an('error');
+          assert(err instanceof Error);
           const errorMessage = err instanceof MatchingError ? err.payload.message : err.message;
           const errorStatus = err instanceof MatchingError ? err.status : undefined;
           debug(`errorMessage: ${errorMessage}, errorStatus: ${errorStatus}`);
-          expect(errorMessage).to.match(new RegExp(expectedSearchError, 'u'));
+          assert.match(errorMessage, new RegExp(expectedSearchError, 'u'));
 
           if (expectedErrorStatus) {
-            expect(errorStatus).to.be(expectedErrorStatus);
+            assert.equal(errorStatus, expectedErrorStatus);
             return;
           }
           return;
         }
       }
 
-      // eslint-disable-next-line functional/no-conditional-statements
       if (!expectedSearchError) {
         const results = await search(searchOptions);
-        expect(formatResults(results)).to.eql(expectedResults);
+        assert.deepStrictEqual(formatResults(results), expectedResults);
       }
 
       function formatResults(results) {
@@ -112,7 +100,6 @@ describe('candidate-search', () => {
           records: results.records.map(({record, id}) => ({id, record: record.toObject()}))
         };
       }
-
     }
   }
 });

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

@@ -1,34 +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-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 {toQueries} from '../candidate-search-utils';
-import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber} from '../../matching-utils';
+import {toQueries} from '../candidate-search-utils.js';
+import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber} from '../../matching-utils.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query');
 
@@ -151,7 +123,13 @@ export function bibMelindaIds(record) {
 // bibHostComponents returns host id from the first subfield $w of first field f773, see test-fixtures 04 and 05
 // bibHostComponents should search all 773 $ws for possible host id, but what should it do in case of multiple host ids?
 export function bibHostComponents(record) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents');
+  const debugData = debug.extend('data');
+  debug(`Creating queries for hostIds`);
+
   const id = getHostId();
+  debugData(`Found id: ${JSON.stringify(id)}`);
+
   return testStringOrNumber(id) ? [`melinda.partsofhost=${id}`] : [];
 
   function getHostId() {
@@ -195,18 +173,25 @@ export function bibTitleAuthor(record) {
 }
 
 export function bibTitleAuthorYear(record) {
-  debug('bibTitleAuthorYear');
+  debug('bibTitleAuthorYearAlternates');
   // We use onlyTitleLength that is longer than our formatted length to
   // get an author or an publisher always
 
   return bibTitleAuthorPublisher({record, onlyTitleLength: 100, addYear: true});
 }
 
-export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = false}) {
-  debug('bibTitleAuthorPublisher');
-  const title = getTitle();
-  const booleanStartWords = ['and', 'or', 'nor', 'not'];
+export function bibTitleAuthorYearAlternates(record) {
+  debug('bibTitleAuthorYearAlternates');
+  // We use onlyTitleLength that is longer than our formatted length to
+  // get an author or an publisher always
+  const origQueryList = bibTitleAuthorPublisher({record, onlyTitleLength: 100, addYear: true, alternates: true, alternateQueries: []});
+  debug(`${JSON.stringify(origQueryList)}`);
+  return {queryList: Array.from(origQueryList).reverse(), queryListType: 'alternates'};
+}
 
+export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = false, alternates = false, alternateQueries = []}) {
+  debug(`bibTitleAuthorPublisher, onlyTitleLength: ${onlyTitleLength}, addYear: ${addYear}, alternates: ${alternates}`);
+  const title = getTitle();
   if (testStringOrNumber(title)) {
     const formatted = String(title)
       .replace(/[^\w\s\p{Alphabetic}]/gu, '')
@@ -217,10 +202,10 @@ export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = fals
       .trim();
 
     // use word search for titles starting with a boolean
-    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+    const useWordSearch = checkUseWordSearch(formatted);
     // Prevent too many matches / SRU crashing by having a minimum length
     // Note that currently this fails matching if there are no matches from previous matchers
-    if (formatted.length >= onlyTitleLength) {
+    if (formatted.length >= onlyTitleLength && !alternates) {
       return [`dc.title="${useWordSearch ? '' : '^'}${formatted}*"`];
     }
     const queryIsOkAlone = formatted.length >= 5;
@@ -228,45 +213,50 @@ export function bibTitleAuthorPublisher({record, onlyTitleLength, addYear = fals
     // use word search without ending * also in combination searches to avoid SRU-server crashes [MRA-189]
     const query = `dc.title="${useWordSearch || !queryIsOkAlone ? '' : '^'}${formatted}${queryIsOkAlone ? '*' : ''}"`;
     debug(`query: ${query}`);
-    return addAuthorsToSearch({query, queryIsOkAlone, addYear});
+    const newAlternateQueries = alternates ? [...alternateQueries, query] : alternateQueries;
+
+    return addAuthorsToSearch({query, queryIsOkAlone, addYear, alternates, alternateQueries: newAlternateQueries});
   }
 
   return [];
 
-  function addAuthorsToSearch({query, queryIsOkAlone = false, addYear = false}) {
+  function addAuthorsToSearch({query, queryIsOkAlone = false, addYear = false, alternates = false, alternateQueries = []}) {
     debug('addAuthorsToSearch');
     const [authorQuery] = bibAuthors(record);
     if (authorQuery !== undefined) {
       if (addYear) {
-        return addYearToSearch({query: `${authorQuery} AND ${query}`, queryIsOkAlone: true});
+        const newAlternateQueries = alternates ? [...alternateQueries, `${authorQuery} AND ${query}`] : alternateQueries;
+        return addYearToSearch({query: `${authorQuery} AND ${query}`, queryIsOkAlone: true, alternates, alternateQueries: newAlternateQueries});
       }
-      return [`${authorQuery} AND ${query}`];
+      return alternates ? alternateQueries : [`${authorQuery} AND ${query}`];
     }
-    return addPublisherToSearch({query, queryIsOkAlone, addYear});
+    return addPublisherToSearch({query, queryIsOkAlone, addYear, alternates, alternateQueries});
     //return [];
   }
 
-  function addPublisherToSearch({query, queryIsOkAlone = false, addYear = false}) {
+  function addPublisherToSearch({query, queryIsOkAlone = false, addYear = false, alternates = false, alternateQueries = []}) {
     const [publisherQuery] = bibPublishers(record);
     if (publisherQuery !== undefined) {
       if (addYear) {
-        return addYearToSearch({query: `${publisherQuery} AND ${query}`, queryIsOkAlone: true});
+        const newAlternateQueries = alternates ? [...alternateQueries, `${publisherQuery} AND ${query}`] : alternateQueries;
+        return addYearToSearch({query: `${publisherQuery} AND ${query}`, queryIsOkAlone: true, alternates, alternateQueries: newAlternateQueries});
       }
-      return [`${publisherQuery} AND ${query}`];
+      return alternates ? alternateQueries : [`${publisherQuery} AND ${query}`];
     }
     if (queryIsOkAlone && !addYear) {
-      return [`${query}`];
+      return alternates ? alternateQueries : [`${query}`];
     }
-    return addYearToSearch({query, queryIsOkAlone});
+    return addYearToSearch({query, queryIsOkAlone, alternates, alternateQueries});
   }
 
-  function addYearToSearch({query, queryIsOkAlone = false}) {
+  function addYearToSearch({query, queryIsOkAlone = false, alternates = false, alternateQueries = []}) {
     const [yearQuery] = bibYear(record);
     if (yearQuery !== undefined) {
-      return [`${yearQuery} AND ${query}`];
+      const newAlternateQueries = alternates ? [...alternateQueries, `${yearQuery} AND ${query}`] : alternateQueries;
+      return alternates ? newAlternateQueries : [`${yearQuery} AND ${query}`];
     }
     if (queryIsOkAlone) {
-      return [`${query}`];
+      return alternates ? alternateQueries : [`${query}`];
     }
     return [];
   }
@@ -296,8 +286,6 @@ export function bibAuthors(record) {
   //debugData(record);
 
   const author = getAuthor(record);
-  const booleanStartWords = ['and', 'or', 'nor', 'not'];
-
 
   if (testStringOrNumber(author)) {
     const formatted = String(author)
@@ -309,7 +297,7 @@ export function bibAuthors(record) {
       .trim();
 
     // use word search for authors starting with a boolean
-    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+    const useWordSearch = checkUseWordSearch(formatted);
     // Prevent too many matches by having a minimum length
     debugData(`Author string: ${formatted}`);
     if (formatted.length >= 5) {
@@ -384,7 +372,6 @@ export function bibYear(record) {
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibYear');
   const debugData = debug.extend('data');
   debug(`Creating query for the publishing year`);
-  debugData(record);
 
   const year = getYear(record);
   if (year) {
@@ -393,11 +380,23 @@ export function bibYear(record) {
   return [];
 
   function getYear(record) {
-    const value = record.get(/^008$/u)?.[0]?.value || undefined;
+    const [f008] = record.get(/^008$/u);
+    if (f008 === undefined) {
+      debug('f008 missing');
+      return false;
+    }
+
+    debugData(`f008: ${JSON.stringify(f008)}`);
+    const {value} = f008;
     return testStringOrNumber(value) ? String(value).slice(7, 11) : undefined;
   }
 }
 
+export function checkUseWordSearch(formatted) {
+  // Note: add a space to startWords to catch just actual boolean words
+  const booleanStartWords = ['and ', 'or ', 'nor ', 'not '];
+  return booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+}
 
 export function bibStandardIdentifiers(record) {
 

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

@@ -0,0 +1,38 @@
+import assert from 'node:assert';
+import {describe} from 'node:test';
+import createDebugLogger from 'debug';
+import generateTests from '@natlibfi/fixugen';
+import {READERS} from '@natlibfi/fixura';
+import {MarcRecord} from '@natlibfi/marc-record';
+import * as generators from './bib.js';
+
+const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents:test');
+const debugData = debug.extend('data');
+
+describe('candidate-search/query-list/bib/', () => {
+  generateTests({
+    path: [import.meta.dirname, '..', '..', '..', 'test-fixtures', 'candidate-search', 'query-list', 'bib'],
+    useMetadataFile: true,
+    fixura: {
+      reader: READERS.JSON
+    },
+    callback: ({type, inputRecord, expectedQuery, expectedQueryListType, enabled = true}) => {
+      const generate = generators[type];
+      const record = new MarcRecord(inputRecord, {subfieldValues: false});
+
+      if (!enabled) {
+        return;
+      }
+
+      const result = generate(record);
+      debugData(`Result: ${JSON.stringify(result)}`);
+
+      if (result.queryListType) {
+        assert.deepStrictEqual(result.queryList, expectedQuery);
+        assert.equal(result.queryListType, expectedQueryListType);
+        return;
+      }
+      assert.deepStrictEqual(result, expectedQuery);
+    }
+  });
+});