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

package/.github/workflows/melinda-node-tests.yml

@@ -11,14 +11,14 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [18.x, 20.x, 21.x, 22.x, 23.x]
+        node-version: [22.x, 24.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
     - name: Checkout the code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
     - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
+      uses: actions/setup-node@v5
       with:
         node-version: ${{ matrix.node-version }}
         cache: 'npm'
@@ -32,10 +32,12 @@ jobs:
   njsscan:
     name: Njsscan check
     runs-on: ubuntu-latest
+    container:
+      image: docker.io/node:22
 
     steps:
     - name: Checkout the code
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
     - name: nodejsscan scan
       id: njsscan
       uses: ajinabraham/njsscan-action@master
@@ -45,9 +47,11 @@ jobs:
   license-scan:
     name: License compliance check
     runs-on: ubuntu-latest
+    container:
+      image: docker.io/node:22
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: mikaelvesavuori/license-compliance-action@v1.0.3
         with:
           exclude_pattern: /^@natlibfi/
@@ -58,9 +62,9 @@ jobs:
     if: contains(github.ref, 'refs/tags/')
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v5
         with:
           node-version: '20.x'
           registry-url: 'https://registry.npmjs.org'

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

@@ -14,115 +14,47 @@
 		"url": "git@github.com:natlibfi/melinda-record-matching-js.git"
 	},
 	"license": "MIT",
-	"version": "4.3.5",
+	"version": "5.0.0-alpha.1",
 	"main": "./dist/index.js",
+	"type": "module",
+	"bin": "./dist/cli.js",
 	"engines": {
-		"node": ">=18"
+		"node": ">=22"
 	},
 	"publishConfig": {
 		"access": "public"
 	},
 	"scripts": {
-		"prepare": "npm run build",
-		"build": "babel src --source-maps --copy-files --delete-dir-on-start --out-dir=dist",
 		"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": "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",
-		"test:base": "cross-env NODE_ENV=test nyc mocha --package ./package.json",
-		"test:dev": "npm run lint:dev && npm run test:base && npm run coverage",
-		"coverage": "nyc check-coverage --per-file",
-		"dev": "nodemon",
-		"dev:debug": "cross-env LOG_LEVEL=debug DEBUG=@natlibfi/* NODE_ENV=test nodemon",
-		"watch:test": "cross-env DEBUG=1 NODE_ENV=test nodemon -w src -w test-fixtures --exec 'npm run test:dev'"
+		"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": "^9.1.4",
-		"@natlibfi/marc-record-serializers": "^10.1.5",
-		"@natlibfi/melinda-commons": "^13.0.19",
-		"@natlibfi/sru-client": "^6.0.18",
-		"debug": "^4.4.0",
-		"isbn3": "^1.2.9",
+		"@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"
+		"winston": "^3.17.0",
+		"yargs": "^18.0.0"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.27.0",
-		"@babel/core": "^7.26.10",
-		"@babel/node": "^7.26.0",
-		"@babel/preset-env": "^7.26.9",
-		"@babel/register": "^7.25.9",
-		"@natlibfi/eslint-config-melinda-backend": "^3.0.5",
-		"@natlibfi/fixugen": "^2.0.13",
-		"@natlibfi/fixugen-http-client": "^3.0.10",
-		"@natlibfi/fixura": "^3.0.12",
-		"babel-plugin-istanbul": "^6.1.1",
-		"babel-plugin-rewire": "^1.2.0",
-		"chai": "^4.5.0",
-		"chai-as-promised": "^7.1.2",
+		"@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.57.1",
-		"mocha": "^11.1.0",
-		"nodemon": "^3.1.9",
-		"nyc": "^17.1.0"
-	},
-	"eslintConfig": {
-		"extends": "@natlibfi/melinda-backend"
-	},
-	"babel": {
-		"presets": [
-			[
-				"@babel/preset-env",
-				{
-					"targets": "maintained node versions"
-				}
-			]
-		],
-		"env": {
-			"test": {
-				"plugins": [
-					"istanbul",
-					"rewire"
-				]
-			}
-		}
-	},
-	"mocha": {
-		"spec": [
-			"src/*.spec.js",
-			"src/**/*.spec.js"
-		],
-		"require": [
-			"@babel/register"
-		],
-		"inline-diffs": true,
-		"maxDiffSize": 25000,
-		"bail": true,
-		"exit": true
-	},
-	"nodemonConfig": {
-		"exec": "npm run test:dev",
-		"watch": [
-			"src/*",
-			"test-fixtures/*"
-		]
-	},
-	"nyc": {
-		"exclude": [
-			"src/*.spec.js",
-			"src/**/*.spec.js"
-		],
-		"reporter": [
-			"text"
-		],
-		"sourceMap": false,
-		"instrument": false,
-		"lines": 80,
-		"statements": 80,
-		"functions": 80,
-		"branches": 80
+		"esbuild": "^0.25.9",
+		"eslint": "^9.35.0"
 	}
 }

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

@@ -1,7 +1,7 @@
 import createDebugLogger from 'debug';
 import createClient, {SruSearchError} from '@natlibfi/sru-client';
 
-export class CandidateSearchError extends Error {}
+export class CandidateSearchError extends Error { }
 
 export default async function ({url, queryList, queryListType, maxCandidates = 50}) {
 
@@ -50,14 +50,12 @@ export default async function ({url, queryList, queryListType, maxCandidates = 5
 
     function retrieveTotal() {
       return new Promise((resolve, reject) => {
-        // eslint-disable-next-line functional/no-let
         let totalRecords = 0;
 
         debug(`Searching total amount of candidates for query: ${query}`);
 
         client.searchRetrieve(query)
           .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}`));

package/src/candidate-search/index.js

@@ -1,14 +1,13 @@
 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';
-import chooseQueries from './choose-queries';
 
-export {searchTypes} from './query-list';
+import generateQueryList from './query-list/index.js';
+import chooseQueries from './choose-queries.js';
 
-export class CandidateSearchError extends Error {}
+export {searchTypes} from './query-list/index.js';
+
+export class CandidateSearchError extends Error { }
 
 // serverMaxResults : maximum size of total search result available from the server, defaults to Aleph's 20000
 
@@ -27,8 +26,16 @@ export default async ({record, searchSpec, url, maxCandidates, maxRecordsPerRequ
   // Do not retrieve more candidates than defined in 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 = generateQueryList(record, searchSpec);
+  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;
 
@@ -42,13 +49,6 @@ export default async ({record, searchSpec, url, maxCandidates, maxRecordsPerRequ
     throw new CandidateSearchError(`Generated query list has invalid type`);
   }
 
-  const client = createClient({
-    url,
-    maxRecordsPerRequest: adjustedMaxRecordsPerRequest,
-    version: '2.0',
-    retrieveAll: false
-  });
-
   debug(`Searching matches for ${inputRecordId}`);
   const chosenQueryList = await filterQueryList({queryList, queryListType});
   debug(`Chosen queries: ${JSON.stringify(chosenQueryList)}`);
@@ -75,97 +75,33 @@ export default async ({record, searchSpec, url, maxCandidates, maxRecordsPerRequ
 
   // 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) {
@@ -179,10 +115,48 @@ export default async ({record, searchSpec, url, maxCandidates, maxRecordsPerRequ
     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,9 +1,10 @@
-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');
@@ -11,7 +12,7 @@ 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
@@ -30,26 +31,28 @@ describe('candidate-search', () => {
       debug(`We're expecting an error`);
       if (expectedFactoryError.isCandidateSearchError) {
         try {
-          const result = createSearchInterface({...formatFactoryOptions(), url});
+          const result = await createSearchInterface({...formatFactoryOptions(), url});
           debug(result);
         } catch (err) {
-          expect(err).to.equal(new CandidateSearchError(expectedFactoryError));
+          assert.equal(err instanceof CandidateSearchError, true);
+          assert.match(err.message, new RegExp(expectedFactoryError.message));
+        } finally {
+          return;
         }
-        return;
       }
 
       try {
-        const result = createSearchInterface({...formatFactoryOptions(), url});
+        const result = await createSearchInterface({...formatFactoryOptions(), url});
         debug(result);
       } catch (err) {
-        expect(err).to.equal(new Error(expectedFactoryError));
+        assert.equal(err instanceof Error, true);
+        assert.match(err.message, new RegExp(expectedFactoryError.message));
+      } finally {
+        return;
       }
-      return;
     }
 
     const {search} = await createSearchInterface({...formatFactoryOptions(), url});
-    // eslint-disable-next-line no-console
-    console.log(search);
     await iterate({searchOptions, expectedSearchError});
 
     function formatFactoryOptions() {
@@ -65,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) {
@@ -98,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,6 +1,6 @@
 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');
 
@@ -372,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) {
@@ -381,7 +380,14 @@ 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;
   }
 }

package/src/candidate-search/query-list/{bib.spec.js → bib.test.js}

@@ -1,16 +1,17 @@
+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 {expect} from 'chai';
 import {MarcRecord} from '@natlibfi/marc-record';
-import * as generators from './bib';
-import createDebugLogger from 'debug';
+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: [__dirname, '..', '..', '..', 'test-fixtures', 'candidate-search', 'query-list', 'bib'],
+    path: [import.meta.dirname, '..', '..', '..', 'test-fixtures', 'candidate-search', 'query-list', 'bib'],
     useMetadataFile: true,
     fixura: {
       reader: READERS.JSON
@@ -27,11 +28,11 @@ describe('candidate-search/query-list/bib/', () => {
       debugData(`Result: ${JSON.stringify(result)}`);
 
       if (result.queryListType) {
-        expect(result.queryList).to.eql(expectedQuery);
-        expect(result.queryListType).to.eql(expectedQueryListType);
+        assert.deepStrictEqual(result.queryList, expectedQuery);
+        assert.equal(result.queryListType, expectedQueryListType);
         return;
       }
-      expect(result).to.eql(expectedQuery);
+      assert.deepStrictEqual(result, expectedQuery);
     }
   });
 });