@natlibfi/melinda-record-matching 2.0.1-alpha.1 → 2.0.7-alpha.1

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

@@ -5,7 +5,7 @@
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *
@@ -28,7 +28,7 @@
 */
 import createDebugLogger from 'debug';
 import {toQueries} from '../candidate-search-utils';
-import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues} from '../../matching-utils';
+import {getMelindaIdsF035, validateSidFieldSubfieldCounts, getSubfieldValues, testStringOrNumber} from '../../matching-utils';
 
 
 export function bibSourceIds(record) {
@@ -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 = testStringOrNumber(subfieldValue) ? String(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 testStringOrNumber(subfieldValue) ? String(subfieldValue).replace(normalizeAwayRegex, '') : '';
         }
 
       }
@@ -151,7 +151,7 @@ export function bibMelindaIds(record) {
 // 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 id = getHostId();
-  return id ? [`melinda.partsofhost=${id}`] : [];
+  return testStringOrNumber(id) ? [`melinda.partsofhost=${id}`] : [];
 
   function getHostId() {
     const [field] = record.get(/^773$/u);
@@ -159,12 +159,12 @@ export function bibHostComponents(record) {
     if (field) {
       const {value} = field.subfields.find(({code}) => code === 'w') || {};
 
-      if (value && (/^\(FI-MELINDA\)/u).test(value)) {
-        return value.replace(/^\(FI-MELINDA\)/u, '');
+      if (testStringOrNumber(value) && (/^\(FI-MELINDA\)/u).test(String(value))) {
+        return String(value).replace(/^\(FI-MELINDA\)/u, '');
       }
 
-      if (value && (/^\(FIN01\)/u).test(value)) {
-        return value.replace(/^\(FIN01\)/u, '');
+      if (testStringOrNumber(value) && (/^\(FIN01\)/u).test(String(value))) {
+        return String(value).replace(/^\(FIN01\)/u, '');
       }
 
       return false;
@@ -175,15 +175,18 @@ export function bibHostComponents(record) {
 
 // SRU search dc.title with a search phrase starting with ^ maps currently in Melinda to
 // (probably) to *headings* index TIT
+// - Aleph cannot currently handle headings searches starting with a boolean - in these cases use word search
+
 // Headings index TIT drops articles etc. from the start of the title according to the filing indicator
 // Currently filing indicator is not implemented - if the title starts with an article and the Melinda
 // record is correctly catalogued using a filing indicator -> dc.title search won't match
 
 export function bibTitle(record) {
   const title = getTitle();
+  const booleanStartWords = ['and', 'or', 'nor', 'not'];
 
-  if (title) {
-    const formatted = title
+  if (testStringOrNumber(title)) {
+    const formatted = String(title)
       .replace(/[^\w\s\p{Alphabetic}]/gu, '')
       // Clean up concurrent spaces from fe. subfield changes
       .replace(/ +/gu, ' ')
@@ -191,33 +194,157 @@ export function bibTitle(record) {
       .slice(0, 30)
       .trim();
 
-    // Prevent too many matches by having a minimum length requirement
-    return formatted.length >= 5 ? [`dc.title="^${formatted}*"`] : [];
+    // use word search for titles starting with a boolean
+    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+    // Prevent too many matches by having a minimum length
+    // Note that currently this fails matching if there are no matches from previous matchers
+    if (formatted.length >= 5) {
+      return [`dc.title="${useWordSearch ? '' : '^'}${formatted}*"`];
+    }
+    // use word search without ending * also in combination searches to avoid SRU-server crashes [MRA-189]
+    return addAuthorsToSearch(`dc.title="${formatted}"`);
   }
 
   return [];
 
+  function addAuthorsToSearch(titleQuery) {
+    const [authorQuery] = bibAuthors(record);
+    if (authorQuery !== undefined) {
+      return [`${authorQuery} AND ${titleQuery}`];
+    }
+    return addPublisherToSearch(titleQuery);
+    //return [];
+  }
+
+  function addPublisherToSearch(query) {
+    const [publisherQuery] = bibPublishers(record);
+    if (publisherQuery !== undefined) {
+      return [`${publisherQuery} AND ${query}`];
+    }
+    return [];
+  }
+
   function getTitle() {
     const [field] = record.get(/^245$/u);
 
     if (field) {
-      return field.subfields
+      const titleString = field.subfields
+        //.filter(({code}) => ['a', 'b', 'n', 'p'].includes(code))
         .filter(({code}) => ['a', 'b'].includes(code))
-        .map(({value}) => value)
+        //.filter(({code}) => ['a'].includes(code))
+        .map(({value}) => testStringOrNumber(value) ? String(value) : '')
+        .filter(value => value)
         // In Melinda's index subfield separators are indexed as ' '
         .join(' ');
+      return titleString;
     }
     return false;
   }
 }
 
-// eslint-disable-next-line max-statements
+export function bibAuthors(record) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibAuthors');
+  const debugData = debug.extend('data');
+  debug(`Creating query for the first author`);
+  //debugData(record);
+
+  const author = getAuthor(record);
+  const booleanStartWords = ['and', 'or', 'nor', 'not'];
+
+
+  if (testStringOrNumber(author)) {
+    const formatted = String(author)
+      .replace(/[^\w\s\p{Alphabetic}]/gu, '')
+      // Clean up concurrent spaces from fe. subfield changes
+      .replace(/ +/gu, ' ')
+      .trim()
+      .slice(0, 30)
+      .trim();
+
+    // use word search for authors starting with a boolean
+    const useWordSearch = booleanStartWords.some(word => formatted.toLowerCase().startsWith(word));
+    // Prevent too many matches by having a minimum length
+    debugData(`Author string: ${formatted}`);
+    if (formatted.length >= 5) {
+      return [`dc.author="${useWordSearch ? '' : '^'}${formatted}*"`];
+    }
+    //if (formatted) {
+    //  return [`dc.author="${formatted}"`];
+    //}
+    return [];
+  }
+
+  return [];
+
+  function getAuthor(record) {
+    //debugData(record);
+    // eslint-disable-next-line prefer-named-capture-group
+    const [field] = record.get(/^(100)|(110)|(111)|(700)|(710)|(711)$/u);
+    //debugData(field);
+
+    if (field) {
+      const authorString = field.subfields
+        .filter(({code}) => ['a'].includes(code))
+        .map(({value}) => testStringOrNumber(value) ? String(value) : '')
+        .filter(value => value)
+        // In Melinda's index subfield separators are indexed as ' '
+        .join(' ');
+      return authorString;
+    }
+    return false;
+  }
+}
+
+export function bibPublishers(record) {
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibPublishers');
+  const debugData = debug.extend('data');
+  debug(`Creating query for the first publisher`);
+  //debugData(record);
+
+  const publisher = getPublisher(record);
+  if (testStringOrNumber(publisher)) {
+    const formatted = String(publisher)
+      .replace(/[^\w\s\p{Alphabetic}]/gu, '')
+      // Clean up concurrent spaces from fe. subfield changes
+      .replace(/ +/gu, ' ')
+      .trim()
+      .slice(0, 30)
+      .trim();
+
+    debugData(`Publisher string: ${formatted}`);
+    // use non-wildcard word search from dc.publisher
+    return [`dc.publisher="${formatted}"`];
+  }
+
+  return [];
+
+  function getPublisher(record) {
+    //debugData(record);
+    const [field] = record.get(/^(?:260)|(?:264)$/u);
+    //debugData(field);
+
+    if (field) {
+      const publisherString = field.subfields
+        .filter(({code}) => ['b'].includes(code))
+        .map(({value}) => testStringOrNumber(value) ? String(value) : '')
+        .filter(value => value)
+        // In Melinda's index subfield separators are indexed as ' '
+        .join(' ');
+      return publisherString;
+    }
+    return false;
+  }
+}
+
+
 export function bibStandardIdentifiers(record) {
 
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:query:bibStandardIdentifiers');
   const debugData = debug.extend('data');
   debug(`Creating queries for standard identifiers`);
 
+  // DEVELOP: should we query also f015 and f028?
+
   const fields = record.get(/^(?<def>020|022|024)$/u);
   const identifiers = [].concat(...fields.map(toIdentifiers));
   const uniqueIdentifiers = [...new Set(identifiers)];
@@ -239,18 +366,18 @@ export function bibStandardIdentifiers(record) {
 
     if (tag === '022') {
       return subfields
-        .filter(sub => ['a', 'z', 'y'].includes(sub.code) && issnIsbnReqExp.test(sub.value) && sub.value !== undefined)
-        .map(({value}) => value);
+        .filter(sub => ['a', 'z', 'y'].includes(sub.code) && testStringOrNumber(sub.value) && issnIsbnReqExp.test(String(sub.value)))
+        .map(({value}) => String(value));
     }
 
     if (tag === '020') {
       return subfields
-        .filter(sub => ['a', 'z'].includes(sub.code) && issnIsbnReqExp.test(sub.value) && sub.value !== undefined)
-        .map(({value}) => value);
+        .filter(sub => ['a', 'z'].includes(sub.code) && testStringOrNumber(sub.value) && issnIsbnReqExp.test(String(sub.value)))
+        .map(({value}) => String(value));
     }
 
     return subfields
-      .filter(sub => ['a', 'z'].includes(sub.code) && otherIdReqExp.test(sub.value) && sub.value !== undefined)
-      .map(({value}) => value);
+      .filter(sub => ['a', 'z'].includes(sub.code) && testStringOrNumber(sub.value) && otherIdReqExp.test(String(sub.value)))
+      .map(({value}) => String(value));
   }
 }

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

@@ -4,7 +4,7 @@
 *
 * Melinda record matching modules for Javascript
 *
-* Copyright (C) 2020 University Of Helsinki (The National Library Of Finland)
+* Copyright (C) 2020-2022 University Of Helsinki (The National Library Of Finland)
 *
 * This file is part of melinda-record-matching-js
 *