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

package/eslint.config.js

@@ -0,0 +1,52 @@
+// Eslint configuration object for src
+const configSrc = {
+  files: [
+    "src/*"
+  ],
+  linterOptions: {
+    reportUnusedDisableDirectives: true,
+  },
+  rules: {
+    "no-console": "warn",
+    "eqeqeq": ["error", "always"],
+    "no-const-assign": "error",
+    "max-depth": ["warn", 4],
+    "max-lines": ["warn", 500],
+    "max-lines-per-function": ["warn", {"max": 100}],
+    "no-else-return": ["error", {allowElseIf: false}],
+    "no-plusplus": [
+      "error",
+      {
+        "allowForLoopAfterthoughts": true
+      }
+    ],
+    "array-callback-return": [
+      "error",
+      {
+        "checkForEach": false
+      }
+    ],
+    "no-unused-vars": [
+      "error",
+      {
+        "argsIgnorePattern": "next"
+      }
+    ],
+    "no-warning-comments": "off"
+  }
+};
+
+// Eslint configuration object for globally ignoring .js files
+// - ignore all files that start with a dot
+// - ignore all files inside directories named 'dist'
+const configIgnores = {
+  ignores: [
+    "**/.*",
+    "**/dist/"
+  ]
+};
+
+export default [
+  configSrc,
+  configIgnores
+];

package/example.env

@@ -0,0 +1,4 @@
+# Local cli
+MELINDA_RECORD_MATCH_SRU_URL='https://sru.url.com/'
+MELINDA_RECORD_MATCH_SEARCH_TYPE='COMPONENT' # 'IDS', 'STANDARD_IDS', 'COMPONENT', 'CONTENT', 'CONTENTALT'
+DEBUG='@natlibfi/*'

package/package.json

@@ -13,11 +13,13 @@
 		"type": "git",
 		"url": "git@github.com:natlibfi/melinda-record-matching-js.git"
 	},
-	"license": "LGPL-3.0+",
-	"version": "4.4.0-alpha.1",
+	"license": "MIT",
+	"version": "5.0.0-alpha.2",
 	"main": "./dist/index.js",
+	"type": "module",
+	"bin": "./dist/cli.js",
 	"engines": {
-		"node": ">=18"
+		"node": ">=22"
 	},
 	"publishConfig": {
 		"access": "public"
@@ -25,86 +27,35 @@
 	"scripts": {
 		"prepare": "npm run build",
 		"start": "node dist/index.js",
+		"build": "esbuild \"src/**/*.js\" --sourcemap --platform=node --outdir=dist",
 		"cli": "node dist/cli.js",
-		"lint": "eslint src",
-		"lint:dev": "eslint --fix src",
-		"test:base": "cross-env NODE_ENV=test nyc mocha --require @babel/register",
-		"test": "npm run lint && npm run test:base -- --recursive src",
-		"test:dev": "npm run lint:dev && npm run test:base -- --recursive src && npm run coverage",
-		"coverage": "nyc check-coverage --per-file",
-		"build": "babel src --source-maps --copy-files --delete-dir-on-start --out-dir=dist",
-		"watch:test": "cross-env DEBUG=1 NODE_ENV=test nodemon -w src -w test-fixtures --exec 'npm run test:dev'"
+		"lint": "eslint ./src",
+		"lint:dev": "eslint --fix ./src",
+		"test:base": "node --test --test-force-exit --experimental-test-coverage --test-reporter=spec './src/*.test.js' './src/**/*.test.js'",
+		"test": "npm run lint && npm run test:base",
+		"watch:test": "cross-env DEBUG=@natlibfi/* NODE_ENV=test node --watch --test --experimental-test-coverage --test-reporter=spec './src/*.test.js' './src/**/*.test.js'",
+		"dev": "npm run watch:test",
+		"dev:debug": "cross-env LOG_LEVEL=debug DEBUG=@natlibfi/* NODE_ENV=test npm run watch:test"
 	},
 	"dependencies": {
-		"@natlibfi/marc-record": "^8.0.0",
-		"@natlibfi/marc-record-serializers": "^10.1.2",
-		"@natlibfi/melinda-commons": "^13.0.8-alpha.1",
-		"@natlibfi/sru-client": "^6.0.5",
-		"debug": "^4.3.4",
-		"isbn3": "^1.1.43",
-		"moment": "^2.29.4",
-		"natural": "^6.8.0",
-		"uuid": "^9.0.1",
-		"winston": "^3.11.0"
+		"@natlibfi/marc-record": "^10.0.0-alpha.1",
+		"@natlibfi/marc-record-serializers": "^11.0.0-alpha.2",
+		"@natlibfi/melinda-commons": "^14.0.0-alpha.3",
+		"@natlibfi/sru-client": "^7.0.0-alpha.1",
+		"debug": "^4.4.1",
+		"isbn3": "^1.2.14",
+		"moment": "^2.30.1",
+		"natural": "^8.0.1",
+		"uuid": "^11.1.0",
+		"winston": "^3.17.0",
+		"yargs": "^18.0.0"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.23.0",
-		"@babel/core": "^7.23.3",
-		"@babel/node": "^7.22.19",
-		"@babel/preset-env": "^7.23.3",
-		"@babel/register": "^7.22.15",
-		"@natlibfi/eslint-config-melinda-backend": "^3.0.3",
-		"@natlibfi/fixugen": "^2.0.2",
-		"@natlibfi/fixugen-http-client": "^3.0.1",
-		"@natlibfi/fixura": "^3.0.2",
-		"babel-plugin-istanbul": "^6.1.1",
-		"babel-plugin-rewire": "^1.2.0",
-		"chai": "^4.3.10",
-		"chai-as-promised": "^7.1.1",
+		"@natlibfi/fixugen": "^3.0.0-alpha.6",
+		"@natlibfi/fixugen-http-client": "^4.0.0-alpha.1",
+		"@natlibfi/fixura": "^4.0.0-alpha.13",
 		"cross-env": "^7.0.3",
-		"eslint": "^8.53.0",
-		"mocha": "^10.2.0",
-		"nodemon": "^3.0.1",
-		"nyc": "^15.1.0"
-	},
-	"eslintConfig": {
-		"extends": "@natlibfi/melinda-backend"
-	},
-	"babel": {
-		"presets": [
-			[
-				"@babel/preset-env",
-				{
-					"targets": "maintained node versions"
-				}
-			]
-		],
-		"env": {
-			"test": {
-				"plugins": [
-					"istanbul",
-					"rewire"
-				]
-			}
-		}
-	},
-	"nyc": {
-		"exclude": [
-			"*/*.spec.js",
-			"*/**/*.spec.js"
-		],
-		"reporter": [
-			"lcov",
-			"html"
-		],
-		"require": [
-			"@babel/register"
-		],
-		"sourceMap": false,
-		"instrument": false,
-		"lines": 80,
-		"statements": 80,
-		"functions": 80,
-		"branches": 80
+		"esbuild": "^0.25.9",
+		"eslint": "^9.35.0"
 	}
 }

package/src/candidate-search/candidate-search-utils.js

@@ -1,31 +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.
-*
-*/
-
 import createDebugLogger from 'debug';
 
 export function toQueries(identifiers, queryString) {
@@ -33,6 +5,7 @@ export function toQueries(identifiers, queryString) {
   const debug = createDebugLogger('@natlibfi/melinda-record-matching:toQueries');
   const debugData = debug.extend('data');
 
+  // We quote the identifier, if it contains a slash! (Slash in non-quoted SRU-search breaks search.)
   const quotedIdentifiers = identifiers.map(identifier => identifier.match(/\//u) ? `"${identifier}"` : `${identifier}`);
 
   // Aleph supports only two queries with or -operator (This is not actually true)

package/src/candidate-search/choose-queries.js

@@ -0,0 +1,93 @@
+import createDebugLogger from 'debug';
+import createClient, {SruSearchError} from '@natlibfi/sru-client';
+
+export class CandidateSearchError extends Error { }
+
+export default async function ({url, queryList, queryListType, maxCandidates = 50}) {
+
+  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:choose-queries');
+  const debugData = debug.extend('data');
+  const debugDev = debug.extend('dev');
+
+  debugData(`Url: ${url}`);
+  debugData(`QueryList: ${queryList}`);
+  debugData(`queryListType: ${queryListType}`);
+
+  const client = createClient({
+    url,
+    maxRecordsPerRequest: 0,
+    version: '2.0',
+    retrieveAll: false
+  });
+
+  debugDev(`QueryList (type: ${queryListType}) ${JSON.stringify(queryList)}`);
+  try {
+    const {queriesWithTotals} = await getQueryTotals({queryList, queryOffset: 0, queriesWithTotals: []});
+    debugDev(`QueryResult: ${JSON.stringify(queriesWithTotals)}`);
+    const filteredQueryResult = filterQueryResult({queriesWithTotals, maxCandidates});
+    debugDev(`filteredQueryResult: ${JSON.stringify(filteredQueryResult)}`);
+    return filteredQueryResult;
+  } catch (err) {
+    throw new CandidateSearchError(err);
+  }
+
+  async function getQueryTotals({queryList, queryOffset = 0, queriesWithTotals = []}) {
+
+    const query = queryList[queryOffset];
+    debug(`Running query ${JSON.stringify(query)} (${queryOffset}) for total`);
+
+    if (query) {
+      const {total} = await retrieveTotal();
+
+      const newQueriesWithTotals = [...queriesWithTotals, {query, total}];
+      debug(`Query ${queryOffset} ${query} done.`);
+      debug(`There are (${queryList.length - (queryOffset + 1)} queries left)`);
+      return getQueryTotals({queryList, queryOffset: queryOffset + 1, queriesWithTotals: newQueriesWithTotals});
+    }
+
+    debug(`All ${queryList.length} queries done, there's no query for ${queryOffset}`);
+    return {queriesWithTotals};
+
+    function retrieveTotal() {
+      return new Promise((resolve, reject) => {
+        let totalRecords = 0;
+
+        debug(`Searching total amount of candidates for query: ${query}`);
+
+        client.searchRetrieve(query)
+          .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', () => {
+            try {
+              resolve({total: totalRecords});
+            } catch (err) {
+              debug(`Error caught on END`);
+              reject(err);
+            }
+          })
+          .on('record', () => {
+            debugDev(`RECORD: We should no get records here`);
+          });
+      });
+    }
+  }
+  function filterQueryResult({queriesWithTotals, maxCandidates}) {
+    debug(`Filtering queries (${queriesWithTotals.length}), maxCandidates: ${maxCandidates}`);
+    debugData(`${JSON.stringify(queriesWithTotals)}`);
+    // Drop queries where total result is 0 or greater than given maxCandidates
+    const filteredQueryResult = queriesWithTotals.filter((queryWithTotal) => queryWithTotal.total !== 0 && queryWithTotal.total < maxCandidates);
+    debugData(`${JSON.stringify(filteredQueryResult)}`);
+    return filteredQueryResult;
+  }
+
+}

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});
+      });
+  });
+}