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

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

@@ -0,0 +1,18 @@
+import createDebugLogger from "debug";
+export function toQueries(identifiers, queryString) {
+  const debug = createDebugLogger("@natlibfi/melinda-record-matching:toQueries");
+  const debugData = debug.extend("data");
+  const quotedIdentifiers = identifiers.map((identifier) => identifier.match(/\//u) ? `"${identifier}"` : `${identifier}`);
+  const pairs = toPairs(quotedIdentifiers);
+  const queries = pairs.map(([a, b]) => b ? `${queryString}=${a} or ${queryString}=${b}` : `${queryString}=${a}`);
+  debugData(`Pairs (${pairs.length}): ${JSON.stringify(pairs)}`);
+  debugData(`Queries (${queries.length}): ${JSON.stringify(queries)}`);
+  return queries;
+}
+function toPairs(array) {
+  if (array.length === 0) {
+    return [];
+  }
+  return [array.slice(0, 2)].concat(toPairs(array.slice(2), 2));
+}
+//# sourceMappingURL=candidate-search-utils.js.map

package/dist/candidate-search/candidate-search-utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/candidate-search/candidate-search-utils.js"],
+  "sourcesContent": ["import createDebugLogger from 'debug';\n\nexport function toQueries(identifiers, queryString) {\n\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:toQueries');\n  const debugData = debug.extend('data');\n\n  // We quote the identifier, if it contains a slash! (Slash in non-quoted SRU-search breaks search.)\n  const quotedIdentifiers = identifiers.map(identifier => identifier.match(/\\//u) ? `\"${identifier}\"` : `${identifier}`);\n\n  // Aleph supports only two queries with or -operator (This is not actually true)\n  const pairs = toPairs(quotedIdentifiers);\n  const queries = pairs.map(([a, b]) => b ? `${queryString}=${a} or ${queryString}=${b}` : `${queryString}=${a}`);\n\n  debugData(`Pairs (${pairs.length}): ${JSON.stringify(pairs)}`);\n  debugData(`Queries (${queries.length}): ${JSON.stringify(queries)}`);\n\n  return queries;\n}\n\nfunction toPairs(array) {\n  if (array.length === 0) {\n    return [];\n  }\n  return [array.slice(0, 2)].concat(toPairs(array.slice(2), 2));\n}\n"],
+  "mappings": "AAAA,OAAO,uBAAuB;AAEvB,gBAAS,UAAU,aAAa,aAAa;AAElD,QAAM,QAAQ,kBAAkB,6CAA6C;AAC7E,QAAM,YAAY,MAAM,OAAO,MAAM;AAGrC,QAAM,oBAAoB,YAAY,IAAI,gBAAc,WAAW,MAAM,KAAK,IAAI,IAAI,UAAU,MAAM,GAAG,UAAU,EAAE;AAGrH,QAAM,QAAQ,QAAQ,iBAAiB;AACvC,QAAM,UAAU,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,IAAI,GAAG,WAAW,IAAI,CAAC,OAAO,WAAW,IAAI,CAAC,KAAK,GAAG,WAAW,IAAI,CAAC,EAAE;AAE9G,YAAU,UAAU,MAAM,MAAM,MAAM,KAAK,UAAU,KAAK,CAAC,EAAE;AAC7D,YAAU,YAAY,QAAQ,MAAM,MAAM,KAAK,UAAU,OAAO,CAAC,EAAE;AAEnE,SAAO;AACT;AAEA,SAAS,QAAQ,OAAO;AACtB,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,CAAC;AAAA,EACV;AACA,SAAO,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,OAAO,QAAQ,MAAM,MAAM,CAAC,GAAG,CAAC,CAAC;AAC9D;",
+  "names": []
+}

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

@@ -0,0 +1,75 @@
+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: queryList2, queryOffset = 0, queriesWithTotals = [] }) {
+    const query = queryList2[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 (${queryList2.length - (queryOffset + 1)} queries left)`);
+      return getQueryTotals({ queryList: queryList2, queryOffset: queryOffset + 1, queriesWithTotals: newQueriesWithTotals });
+    }
+    debug(`All ${queryList2.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: maxCandidates2 }) {
+    debug(`Filtering queries (${queriesWithTotals.length}), maxCandidates: ${maxCandidates2}`);
+    debugData(`${JSON.stringify(queriesWithTotals)}`);
+    const filteredQueryResult = queriesWithTotals.filter((queryWithTotal) => queryWithTotal.total !== 0 && queryWithTotal.total < maxCandidates2);
+    debugData(`${JSON.stringify(filteredQueryResult)}`);
+    return filteredQueryResult;
+  }
+}
+//# sourceMappingURL=choose-queries.js.map

package/dist/candidate-search/choose-queries.js.map

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

package/dist/candidate-search/index.js

@@ -0,0 +1,118 @@
+import createDebugLogger from "debug";
+import createClient, { SruSearchError } from "@natlibfi/sru-client";
+import { MarcRecord } from "@natlibfi/marc-record";
+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 default async ({ record, searchSpec, url, maxCandidates, maxRecordsPerRequest = 50, serverMaxResult = 2e4 }) => {
+  MarcRecord.setValidationOptions({ subfieldValues: false });
+  const debug = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search");
+  const debugData = debug.extend("data");
+  debugData(`SearchSpec: ${JSON.stringify(searchSpec)}`);
+  debugData(`Url: ${url}`);
+  debugData(`MaxRecordsPerRequest ${maxRecordsPerRequest}`);
+  debugData(`ServerMaxResult: ${serverMaxResult}`);
+  debugData(`MaxCandidates: ${maxCandidates}`);
+  const adjustedMaxRecordsPerRequest = maxRecordsPerRequest >= maxCandidates ? maxCandidates : maxRecordsPerRequest;
+  const client = createClient({
+    url,
+    maxRecordsPerRequest: adjustedMaxRecordsPerRequest,
+    version: "2.0",
+    retrieveAll: false,
+    metadataFormat: "marcJson"
+  });
+  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 : void 0;
+  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: queryList2, queryListType: queryListType2, maxCandidates: maxCandidates2 }) {
+    debug(`Generated queryList (type: ${queryListType2}) ${JSON.stringify(queryList2)}`);
+    if (queryListType2 === "alternates" && queryList2.length > 1) {
+      const queryListResult2 = await chooseQueries({ url, queryList: queryList2, queryListType: queryListType2, maxCandidates: maxCandidates2 });
+      debug(`queryListResult: ${JSON.stringify(queryListResult2)}`);
+      return queryListResult2.map((elem) => elem.query);
+    }
+    return queryList2;
+  }
+  return { search };
+  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, nextOffset, total } = await retrieveRecords(client, query, resultSetOffset);
+      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 : queryCandidateCounter + records.length;
+      const maxedQuery = resultSetOffset === 1 ? checkMaxedQuery(query, total, serverMaxResult) : void 0;
+      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, 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, 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: [], queriesLeft: 0, queryCounter, maxedQueries };
+  }
+  function checkMaxedQuery(query, total, serverMaxResult2) {
+    if (total >= serverMaxResult2) {
+      debug(`WARNING: Query ${query} resulted in ${total} hits which meets the serverMaxResult (${serverMaxResult2}) `);
+      return query;
+    }
+  }
+  function getRecordId(record2) {
+    const [field] = record2.get(/^001$/u);
+    return field ? field.value : "";
+  }
+};
+export function retrieveRecords(client, query, resultSetOffset) {
+  const debug = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:retrieveRecords");
+  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 });
+    });
+  });
+}
+//# sourceMappingURL=index.js.map

package/dist/candidate-search/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/candidate-search/index.js"],
+  "sourcesContent": ["import createDebugLogger from 'debug';\nimport createClient, {SruSearchError} from '@natlibfi/sru-client';\nimport {MarcRecord} from '@natlibfi/marc-record';\n\nimport generateQueryList from './query-list/index.js';\nimport chooseQueries from './choose-queries.js';\n\nexport {searchTypes} from './query-list/index.js';\n\nexport class CandidateSearchError extends Error { }\n\n// serverMaxResults : maximum size of total search result available from the server, defaults to Aleph's 20000\n\nexport default async ({record, searchSpec, url, maxCandidates, maxRecordsPerRequest = 50, serverMaxResult = 20000}) => {\n  MarcRecord.setValidationOptions({subfieldValues: false});\n\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search');\n  const debugData = debug.extend('data');\n\n  debugData(`SearchSpec: ${JSON.stringify(searchSpec)}`);\n  debugData(`Url: ${url}`);\n  debugData(`MaxRecordsPerRequest ${maxRecordsPerRequest}`);\n  debugData(`ServerMaxResult: ${serverMaxResult}`);\n  debugData(`MaxCandidates: ${maxCandidates}`);\n\n  // Do not retrieve more candidates than defined in maxCandidates\n  const adjustedMaxRecordsPerRequest = maxRecordsPerRequest >= maxCandidates ? maxCandidates : maxRecordsPerRequest;\n\n  const client = createClient({\n    url,\n    maxRecordsPerRequest: adjustedMaxRecordsPerRequest,\n    version: '2.0',\n    retrieveAll: false,\n    metadataFormat: 'marcJson'\n  });\n\n  const inputRecordId = getRecordId(record);\n  const queryListResult = await generateQueryList(record, searchSpec, client);\n  const queryList = queryListResult[0]?.queryList ? queryListResult[0].queryList : queryListResult;\n  const queryListType = queryListResult[0]?.queryListType ? queryListResult[0].queryListType : undefined;\n\n  // if generateQueryList errored we should throw 422\n  if (queryList.length === 0) {\n    debug(`Empty list`);\n    throw new CandidateSearchError(`Generated query list contains no queries`);\n  }\n  if (queryListType && queryListType !== 'alternates') {\n    debug(`Unknown queryListType`);\n    throw new CandidateSearchError(`Generated query list has invalid type`);\n  }\n\n  debug(`Searching matches for ${inputRecordId}`);\n  const chosenQueryList = await filterQueryList({queryList, queryListType});\n  debug(`Chosen queries: ${JSON.stringify(chosenQueryList)}`);\n\n  async function filterQueryList({queryList, queryListType, maxCandidates}) {\n    debug(`Generated queryList (type: ${queryListType}) ${JSON.stringify(queryList)}`);\n\n    if (queryListType === 'alternates' && queryList.length > 1) {\n      const queryListResult = await chooseQueries({url, queryList, queryListType, maxCandidates});\n      debug(`queryListResult: ${JSON.stringify(queryListResult)}`);\n      return queryListResult.map(elem => elem.query);\n    }\n    return queryList;\n  }\n  // state.totalRecords : amount of candidate records available to the current query (undefined, if there was no queries left)\n  // state.query : current query (undefined if there was no queries left)\n  // state.searchCounter : sequence for current search for current query (undefined, if there we no queries left)\n  // state.queryCandidateCounter: amount of candidates (records+failures) retrieved from SRU for matching for current query, including the current record+failure set (undefined if there were no queries left)\n  // state.queriesLeft : amount of queries left\n  // state.queryCounter : sequence for current query\n  // state.maxedQueries : queries that resulted in more than serverMaxResults hits\n\n  return {search};\n\n  // eslint-disable-next-line max-statements\n  async function search({queryOffset = 0, resultSetOffset = 1, totalRecords = 0, searchCounter = 0, queryCandidateCounter = 0, queryCounter = 0, maxedQueries = []}) {\n    const query = chosenQueryList[queryOffset];\n    debug(`Running query ${JSON.stringify(query)} (${queryOffset})`);\n\n    if (query) {\n      const {records, nextOffset, total} = await retrieveRecords(client, query, resultSetOffset);\n\n      // If resultSetOffset === 1 this is the first search for the current query\n      debugData(`ResultSetOffset: ${resultSetOffset}`);\n      const newTotalRecords = resultSetOffset === 1 ? total : totalRecords;\n      const newQueryCounter = resultSetOffset === 1 ? queryCounter + 1 : queryCounter;\n      const newSearchCounter = resultSetOffset === 1 ? 1 : searchCounter + 1;\n      const newQueryCandidateCounter = resultSetOffset === 1 ? records.length : queryCandidateCounter + records.length;\n\n      const maxedQuery = resultSetOffset === 1 ? checkMaxedQuery(query, total, serverMaxResult) : undefined;\n      const newMaxedQueries = maxedQuery ? maxedQueries.concat(maxedQuery) : maxedQueries;\n\n      if (typeof nextOffset === 'number') {\n        debug(`Next search will be for query ${queryOffset} ${query}, starting from record ${nextOffset}`);\n        return {records, queryOffset, resultSetOffset: nextOffset, queriesLeft: queryList.length - (queryOffset + 1), totalRecords: newTotalRecords, query, searchCounter: newSearchCounter, queryCandidateCounter: newQueryCandidateCounter, queryCounter: newQueryCounter, maxedQueries: newMaxedQueries};\n      }\n      debug(`Query ${queryOffset} ${query} done.`);\n      debug(`There are (${queryList.length - (queryOffset + 1)} queries left)`);\n      return {records, queryOffset: queryOffset + 1, queriesLeft: queryList.length - (queryOffset + 1), totalRecords: newTotalRecords, query, searchCounter: newSearchCounter, queryCandidateCounter: newQueryCandidateCounter, queryCounter: newQueryCounter, maxedQueries: newMaxedQueries};\n    }\n\n    debug(`All ${queryList.length} queries done, there's no query for ${queryOffset}`);\n    return {records: [], queriesLeft: 0, queryCounter, maxedQueries};\n  }\n\n  function checkMaxedQuery(query, total, serverMaxResult) {\n    if (total >= serverMaxResult) {\n      debug(`WARNING: Query ${query} resulted in ${total} hits which meets the serverMaxResult (${serverMaxResult}) `);\n      return query;\n    }\n  }\n\n  function getRecordId(record) {\n    const [field] = record.get(/^001$/u);\n    return field ? field.value : '';\n  }\n};\n\nexport function retrieveRecords(client, query, resultSetOffset) {\n  const debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:retrieveRecords');\n  // eslint-disable-next-line no-unused-vars\n  const debugData = debug.extend('data');\n\n  return new Promise((resolve, reject) => {\n    const records = [];\n    let totalRecords = 0;\n\n    debug(`Searching for candidates with query: ${query} (Offset ${resultSetOffset})`);\n\n    client.searchRetrieve(query, {startRecord: resultSetOffset})\n      .on('error', err => {\n        if (err instanceof SruSearchError) {\n          debug(`SRU SruSearchError for query: ${query}: ${err}`);\n          reject(new CandidateSearchError(`SRU SruSearchError for query: ${query}: ${err}`));\n        }\n\n        debug(`SRU error for query: ${query}: ${err}`);\n        reject(new CandidateSearchError(`SRU error for query: ${query}: ${err}`));\n      })\n      .on('total', total => {\n        debug(`Got total: ${total}`);\n        totalRecords += total;\n      })\n      .on('end', nextOffset => {\n        try {\n          debug(`Found ${records.length} records`);\n\n          resolve({nextOffset, records, total: totalRecords});\n        } catch (err) {\n          debug(`Error caught on END`);\n          reject(err);\n        }\n      })\n      .on('record', record => {\n        const [field] = record.get(/^001$/u);\n        debug(field);\n        const id = field.value ? field.value : '';\n        records.push({record, id});\n      });\n  });\n}\n"],
+  "mappings": "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",
+  "names": ["queryList", "queryListType", "maxCandidates", "queryListResult", "serverMaxResult", "record"]
+}

package/dist/candidate-search/index.test.js

@@ -0,0 +1,92 @@
+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 "./index.js";
+import createDebugLogger from "debug";
+const debug = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:test");
+describe("candidate-search", () => {
+  generateTests({
+    callback,
+    path: [import.meta.dirname, "..", "..", "test-fixtures", "candidate-search", "index"],
+    recurse: false,
+    fixura: {
+      reader: READERS.JSON
+    }
+  });
+  async function callback({ getFixture, factoryOptions, searchOptions, expectedFactoryError = false, expectedSearchError = false, enabled = true }) {
+    const url = "http://foo.bar";
+    if (!enabled) {
+      return;
+    }
+    if (expectedFactoryError) {
+      debug(`We're expecting an error`);
+      if (expectedFactoryError.isCandidateSearchError) {
+        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;
+        }
+      }
+      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 } = await createSearchInterface({ ...formatFactoryOptions(), url });
+    await iterate({ searchOptions, expectedSearchError });
+    function formatFactoryOptions() {
+      debug(`Using factoryOptions: ${JSON.stringify(factoryOptions)}`);
+      return {
+        ...factoryOptions,
+        maxRecordsPerRequest: factoryOptions.maxRecordsPerRequest || 1,
+        maxServerResults: factoryOptions.maxServerResults || void 0,
+        record: new MarcRecord(factoryOptions.record, { subfieldValues: false })
+      };
+    }
+    async function iterate({ searchOptions: searchOptions2, expectedSearchError: expectedSearchError2, expectedErrorStatus, count = 1 }) {
+      const expectedResults = getFixture(`expectedResults${count}.json`);
+      if (expectedSearchError2) {
+        try {
+          await search(searchOptions2);
+          throw new Error("Expected an error");
+        } catch (err) {
+          debug(`Got an error: ${err}`);
+          assert(err instanceof Error);
+          const errorMessage = err instanceof MatchingError ? err.payload.message : err.message;
+          const errorStatus = err instanceof MatchingError ? err.status : void 0;
+          debug(`errorMessage: ${errorMessage}, errorStatus: ${errorStatus}`);
+          assert.match(errorMessage, new RegExp(expectedSearchError2, "u"));
+          if (expectedErrorStatus) {
+            assert.equal(errorStatus, expectedErrorStatus);
+            return;
+          }
+          return;
+        }
+      }
+      if (!expectedSearchError2) {
+        const results = await search(searchOptions2);
+        assert.deepStrictEqual(formatResults(results), expectedResults);
+      }
+      function formatResults(results) {
+        debug(results);
+        return {
+          ...results,
+          records: results.records.map(({ record, id }) => ({ id, record: record.toObject() }))
+        };
+      }
+    }
+  }
+});
+//# sourceMappingURL=index.test.js.map

package/dist/candidate-search/index.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/candidate-search/index.test.js"],
+  "sourcesContent": ["import assert from 'node:assert';\nimport {describe} from 'node:test';\nimport {READERS} from '@natlibfi/fixura';\nimport generateTests from '@natlibfi/fixugen-http-client';\nimport {MarcRecord} from '@natlibfi/marc-record';\nimport {Error as MatchingError} from '@natlibfi/melinda-commons';\nimport createSearchInterface, {CandidateSearchError} from './index.js';\nimport createDebugLogger from 'debug';\n\nconst debug = createDebugLogger('@natlibfi/melinda-record-matching:candidate-search:test');\n\ndescribe('candidate-search', () => {\n  generateTests({\n    callback,\n    path: [import.meta.dirname, '..', '..', 'test-fixtures', 'candidate-search', 'index'],\n    recurse: false,\n    fixura: {\n      reader: READERS.JSON\n    }\n  });\n\n  // eslint-disable-next-line max-statements\n  async function callback({getFixture, factoryOptions, searchOptions, expectedFactoryError = false, expectedSearchError = false, enabled = true}) {\n    const url = 'http://foo.bar';\n\n    if (!enabled) {\n      return;\n    }\n\n    if (expectedFactoryError) {\n      debug(`We're expecting an error`);\n      if (expectedFactoryError.isCandidateSearchError) {\n        try {\n          const result = await createSearchInterface({...formatFactoryOptions(), url});\n          debug(result);\n        } catch (err) {\n          assert.equal(err instanceof CandidateSearchError, true);\n          assert.match(err.message, new RegExp(expectedFactoryError.message));\n        } finally {\n          return;\n        }\n      }\n\n      try {\n        const result = await createSearchInterface({...formatFactoryOptions(), url});\n        debug(result);\n      } catch (err) {\n        assert.equal(err instanceof Error, true);\n        assert.match(err.message, new RegExp(expectedFactoryError.message));\n      } finally {\n        return;\n      }\n    }\n\n    const {search} = await createSearchInterface({...formatFactoryOptions(), url});\n    await iterate({searchOptions, expectedSearchError});\n\n    function formatFactoryOptions() {\n      debug(`Using factoryOptions: ${JSON.stringify(factoryOptions)}`);\n      return {\n        ...factoryOptions,\n        maxRecordsPerRequest: factoryOptions.maxRecordsPerRequest || 1,\n        maxServerResults: factoryOptions.maxServerResults || undefined,\n        record: new MarcRecord(factoryOptions.record, {subfieldValues: false})\n      };\n    }\n\n    async function iterate({searchOptions, expectedSearchError, expectedErrorStatus, count = 1}) {\n      const expectedResults = getFixture(`expectedResults${count}.json`);\n\n      if (expectedSearchError) {\n        try {\n          await search(searchOptions);\n          throw new Error('Expected an error');\n        } catch (err) {\n          debug(`Got an error: ${err}`);\n          assert(err instanceof Error);\n          const errorMessage = err instanceof MatchingError ? err.payload.message : err.message;\n          const errorStatus = err instanceof MatchingError ? err.status : undefined;\n          debug(`errorMessage: ${errorMessage}, errorStatus: ${errorStatus}`);\n          assert.match(errorMessage, new RegExp(expectedSearchError, 'u'));\n\n          if (expectedErrorStatus) {\n            assert.equal(errorStatus, expectedErrorStatus);\n            return;\n          }\n          return;\n        }\n      }\n\n      if (!expectedSearchError) {\n        const results = await search(searchOptions);\n        assert.deepStrictEqual(formatResults(results), expectedResults);\n      }\n\n      function formatResults(results) {\n        debug(results);\n        return {\n          ...results,\n          records: results.records.map(({record, id}) => ({id, record: record.toObject()}))\n        };\n      }\n    }\n  }\n});\n"],
+  "mappings": "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",
+  "names": ["searchOptions", "expectedSearchError"]
+}

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

@@ -0,0 +1,260 @@
+import createDebugLogger from "debug";
+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");
+export function bibSourceIds(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:source-ids");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for sourceid's`);
+  const fSids = record.get("SID");
+  debugData(`SID-fields (${fSids.length}): ${JSON.stringify(fSids)}`);
+  return fSids.length > 0 ? toSidQueries(fSids) : [];
+  function toSidQueries(fSids2) {
+    debug2(`Creating actual queries for sourceid's`);
+    const sidStrings = getSidStrings(fSids2);
+    if (sidStrings.length < 1) {
+      debug2(`No identifiers found, no queries created.`);
+      return [];
+    }
+    const sidQueries = toQueries(sidStrings, "melinda.sourceid");
+    return sidQueries;
+    function getSidStrings(fSids3) {
+      debug2(`Getting Sid strings from SID fields`);
+      const sidStrings2 = fSids3.map(toSidString).filter((nonEmptySid) => nonEmptySid);
+      return sidStrings2;
+      function toSidString(field) {
+        debug2(`Getting string from a field`);
+        return validateSidFieldSubfieldCounts(field) ? createSidString(field) : "";
+        function createSidString(field2) {
+          debug2(`Creating string from a field`);
+          const [sfC] = getSubfieldValues(field2, "c");
+          const [sfB] = getSubfieldValues(field2, "b");
+          const cleanedSfC = removeSourcePrefix(normalizeSidSubfieldValue(sfC));
+          const cleanedSfB = normalizeSidSubfieldValue(sfB);
+          debugData(`${JSON.stringify(sfC)} + ${JSON.stringify(sfB)}`);
+          return cleanedSfC.concat(cleanedSfB);
+        }
+        function removeSourcePrefix(subfieldValue) {
+          const sourcePrefixRegex = /^(?<sourcePrefix>\([A-Za-z0-9-]+\))(?<id>.+)$/u;
+          const normalizedValue = testStringOrNumber(subfieldValue) ? String(subfieldValue).replace(sourcePrefixRegex, "$<id>") : "";
+          debugData(`Normalized ${subfieldValue} to ${normalizedValue}`);
+          return normalizedValue;
+        }
+        function normalizeSidSubfieldValue(subfieldValue) {
+          debugData(`Normalizing ${subfieldValue}`);
+          const normalizeAwayRegex = /[- ]/u;
+          return testStringOrNumber(subfieldValue) ? String(subfieldValue).replace(normalizeAwayRegex, "") : "";
+        }
+      }
+    }
+  }
+}
+export function bibMelindaIds(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibMelindaIds");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for MelindaIds`);
+  const melindaIds = getMelindaIdsF035(record);
+  debugData(`Unique identifiers (${melindaIds.length}): ${JSON.stringify(melindaIds)}`);
+  if (melindaIds.length < 1) {
+    debug2(`No identifiers found, no queries created.`);
+    return [];
+  }
+  return toQueries(melindaIds, "melinda.melindaid");
+}
+export function bibHostComponents(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibHostComponents");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for hostIds`);
+  const id = getHostId();
+  debugData(`Found id: ${JSON.stringify(id)}`);
+  return testStringOrNumber(id) ? [`melinda.partsofhost=${id}`] : [];
+  function getHostId() {
+    const [field] = record.get(/^773$/u);
+    if (field) {
+      const { value } = field.subfields.find(({ code }) => code === "w") || {};
+      if (testStringOrNumber(value) && /^\(FI-MELINDA\)/u.test(String(value))) {
+        return String(value).replace(/^\(FI-MELINDA\)/u, "");
+      }
+      if (testStringOrNumber(value) && /^\(FIN01\)/u.test(String(value))) {
+        return String(value).replace(/^\(FIN01\)/u, "");
+      }
+      return false;
+    }
+    return false;
+  }
+}
+export function bibTitle(record) {
+  return bibTitleAuthorPublisher({ record, onlyTitleLength: 5 });
+}
+export function bibTitleAuthor(record) {
+  debug("bibTitleAuthor");
+  return bibTitleAuthorPublisher({ record, onlyTitleLength: 100 });
+}
+export function bibTitleAuthorYear(record) {
+  debug("bibTitleAuthorYearAlternates");
+  return bibTitleAuthorPublisher({ record, onlyTitleLength: 100, addYear: true });
+}
+export function bibTitleAuthorYearAlternates(record) {
+  debug("bibTitleAuthorYearAlternates");
+  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, "").replace(/ +/gu, " ").trim().slice(0, 30).trim();
+    const useWordSearch = checkUseWordSearch(formatted);
+    if (formatted.length >= onlyTitleLength && !alternates) {
+      return [`dc.title="${useWordSearch ? "" : "^"}${formatted}*"`];
+    }
+    const queryIsOkAlone = formatted.length >= 5;
+    const query = `dc.title="${useWordSearch || !queryIsOkAlone ? "" : "^"}${formatted}${queryIsOkAlone ? "*" : ""}"`;
+    debug(`query: ${query}`);
+    const newAlternateQueries = alternates ? [...alternateQueries, query] : alternateQueries;
+    return addAuthorsToSearch({ query, queryIsOkAlone, addYear, alternates, alternateQueries: newAlternateQueries });
+  }
+  return [];
+  function addAuthorsToSearch({ query, queryIsOkAlone = false, addYear: addYear2 = false, alternates: alternates2 = false, alternateQueries: alternateQueries2 = [] }) {
+    debug("addAuthorsToSearch");
+    const [authorQuery] = bibAuthors(record);
+    if (authorQuery !== void 0) {
+      if (addYear2) {
+        const newAlternateQueries = alternates2 ? [...alternateQueries2, `${authorQuery} AND ${query}`] : alternateQueries2;
+        return addYearToSearch({ query: `${authorQuery} AND ${query}`, queryIsOkAlone: true, alternates: alternates2, alternateQueries: newAlternateQueries });
+      }
+      return alternates2 ? alternateQueries2 : [`${authorQuery} AND ${query}`];
+    }
+    return addPublisherToSearch({ query, queryIsOkAlone, addYear: addYear2, alternates: alternates2, alternateQueries: alternateQueries2 });
+  }
+  function addPublisherToSearch({ query, queryIsOkAlone = false, addYear: addYear2 = false, alternates: alternates2 = false, alternateQueries: alternateQueries2 = [] }) {
+    const [publisherQuery] = bibPublishers(record);
+    if (publisherQuery !== void 0) {
+      if (addYear2) {
+        const newAlternateQueries = alternates2 ? [...alternateQueries2, `${publisherQuery} AND ${query}`] : alternateQueries2;
+        return addYearToSearch({ query: `${publisherQuery} AND ${query}`, queryIsOkAlone: true, alternates: alternates2, alternateQueries: newAlternateQueries });
+      }
+      return alternates2 ? alternateQueries2 : [`${publisherQuery} AND ${query}`];
+    }
+    if (queryIsOkAlone && !addYear2) {
+      return alternates2 ? alternateQueries2 : [`${query}`];
+    }
+    return addYearToSearch({ query, queryIsOkAlone, alternates: alternates2, alternateQueries: alternateQueries2 });
+  }
+  function addYearToSearch({ query, queryIsOkAlone = false, alternates: alternates2 = false, alternateQueries: alternateQueries2 = [] }) {
+    const [yearQuery] = bibYear(record);
+    if (yearQuery !== void 0) {
+      const newAlternateQueries = alternates2 ? [...alternateQueries2, `${yearQuery} AND ${query}`] : alternateQueries2;
+      return alternates2 ? newAlternateQueries : [`${yearQuery} AND ${query}`];
+    }
+    if (queryIsOkAlone) {
+      return alternates2 ? alternateQueries2 : [`${query}`];
+    }
+    return [];
+  }
+  function getTitle() {
+    const [field] = record.get(/^245$/u);
+    if (field) {
+      const titleString = field.subfields.filter(({ code }) => ["a", "b"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value).join(" ");
+      return titleString;
+    }
+    return false;
+  }
+}
+export function bibAuthors(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibAuthors");
+  const debugData = debug2.extend("data");
+  debug2(`Creating query for the first author`);
+  const author = getAuthor(record);
+  if (testStringOrNumber(author)) {
+    const formatted = String(author).replace(/[^\w\s\p{Alphabetic}]/gu, "").replace(/ +/gu, " ").trim().slice(0, 30).trim();
+    const useWordSearch = checkUseWordSearch(formatted);
+    debugData(`Author string: ${formatted}`);
+    if (formatted.length >= 5) {
+      return [`dc.author="${useWordSearch ? "" : "^"}${formatted}*"`];
+    }
+    return [];
+  }
+  return [];
+  function getAuthor(record2) {
+    const [field] = record2.get(/^(100)|(110)|(111)|(700)|(710)|(711)$/u);
+    if (field) {
+      const authorString = field.subfields.filter(({ code }) => ["a"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value).join(" ");
+      return authorString;
+    }
+    return false;
+  }
+}
+export function bibPublishers(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibPublishers");
+  const debugData = debug2.extend("data");
+  debug2(`Creating query for the first publisher`);
+  const publisher = getPublisher(record);
+  if (testStringOrNumber(publisher)) {
+    const formatted = String(publisher).replace(/[^\w\s\p{Alphabetic}]/gu, "").replace(/ +/gu, " ").trim().slice(0, 30).trim();
+    debugData(`Publisher string: ${formatted}`);
+    return [`dc.publisher="${formatted}"`];
+  }
+  return [];
+  function getPublisher(record2) {
+    const [field] = record2.get(/^(?:260)|(?:264)$/u);
+    if (field) {
+      const publisherString = field.subfields.filter(({ code }) => ["b"].includes(code)).map(({ value }) => testStringOrNumber(value) ? String(value) : "").filter((value) => value).join(" ");
+      return publisherString;
+    }
+    return false;
+  }
+}
+export function bibYear(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibYear");
+  const debugData = debug2.extend("data");
+  debug2(`Creating query for the publishing year`);
+  const year = getYear(record);
+  if (year) {
+    return [`dc.date="${year}"`];
+  }
+  return [];
+  function getYear(record2) {
+    const [f008] = record2.get(/^008$/u);
+    if (f008 === void 0) {
+      debug2("f008 missing");
+      return false;
+    }
+    debugData(`f008: ${JSON.stringify(f008)}`);
+    const { value } = f008;
+    return testStringOrNumber(value) ? String(value).slice(7, 11) : void 0;
+  }
+}
+export function checkUseWordSearch(formatted) {
+  const booleanStartWords = ["and ", "or ", "nor ", "not "];
+  return booleanStartWords.some((word) => formatted.toLowerCase().startsWith(word));
+}
+export function bibStandardIdentifiers(record) {
+  const debug2 = createDebugLogger("@natlibfi/melinda-record-matching:candidate-search:query:bibStandardIdentifiers");
+  const debugData = debug2.extend("data");
+  debug2(`Creating queries for standard identifiers`);
+  const fields = record.get(/^(?<def>020|022|024)$/u);
+  const identifiers = [].concat(...fields.map(toIdentifiers));
+  const uniqueIdentifiers = [...new Set(identifiers)];
+  debugData(`Standard identifier fields: ${JSON.stringify(fields)}`);
+  debugData(`Identifiers (${identifiers.length}): ${JSON.stringify(identifiers)}`);
+  debugData(`Unique identifiers (${uniqueIdentifiers.length}): ${JSON.stringify(uniqueIdentifiers)}`);
+  if (uniqueIdentifiers.length < 1) {
+    debug2(`No identifiers found, no queries created.`);
+    return [];
+  }
+  return toQueries(uniqueIdentifiers, "dc.identifier");
+  function toIdentifiers({ tag, subfields }) {
+    const issnIsbnReqExp = /^[A-Za-z0-9-]+$/u;
+    const otherIdReqExp = /^[A-Za-z0-9-:]+$/u;
+    if (tag === "022") {
+      return subfields.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) && testStringOrNumber(sub.value) && issnIsbnReqExp.test(String(sub.value))).map(({ value }) => String(value));
+    }
+    return subfields.filter((sub) => ["a", "z"].includes(sub.code) && testStringOrNumber(sub.value) && otherIdReqExp.test(String(sub.value))).map(({ value }) => String(value));
+  }
+}
+//# sourceMappingURL=bib.js.map