@natlibfi/melinda-rest-api-commons 6.1.0-alpha.0 → 6.2.0-alpha.0

package/{tests/helpers/conversion.test.js → test/helpers/conversion.test.ts}

@@ -1,12 +1,11 @@
-
-
 import assert from 'node:assert';
 import {describe, it} from 'node:test';
 import fixtureFactory from '@natlibfi/fixura';
 import {MarcRecord} from '@natlibfi/marc-record';
+import type {MarcRecordObject} from '@natlibfi/marc-record';
 import {Error as ConversionError} from '@natlibfi/melinda-commons';
-import createConversionService from '../../src/helpers/conversion.js';
-import {CONVERSION_FORMATS} from '../../src/constants.js';
+import createConversionService from '../../src/helpers/conversion.ts';
+import {CONVERSION_FORMATS} from '../../src/constants.ts';
 
 describe('services/conversion', () => {
   const {getFixture} = fixtureFactory({
@@ -20,11 +19,11 @@ describe('services/conversion', () => {
   });
   const conversionService = createConversionService();
 
-  const marcRecord = new MarcRecord(JSON.parse(getFixture({components: ['json1']})), {subfieldValues: false});
-  const marcXml = getFixture({components: ['marcxml1']});
-  const iso2709 = getFixture({components: ['iso2709_1']});
-  const json = getFixture({components: ['json1']});
-  const alephSeq = getFixture({components: ['aleph_sequential']});
+  const marcRecord = new MarcRecord(JSON.parse(getFixture({components: ['json1']}) as string) as MarcRecordObject, {subfieldValues: false});
+  const marcXml = getFixture({components: ['marcxml1']}) as string;
+  const iso2709 = getFixture({components: ['iso2709_1']}) as string;
+  const json = getFixture({components: ['json1']}) as string;
+  const alephSeq = getFixture({components: ['aleph_sequential']}) as string;
 
 
   describe('factory', () => {
@@ -38,11 +37,16 @@ describe('services/conversion', () => {
 
   describe('#serialize', () => {
     it('Should throw because of unsupported format', () => {
+      let threw = false;
       try {
-        conversionService.serialize();
+        // the undefined inputs are the point of this test: serialize must
+        // throw a ConversionError for an unsupported format, not a TypeError
+        conversionService.serialize(undefined as never, undefined as never);
       } catch (error) {
+        threw = true;
         assert(error instanceof ConversionError);
       }
+      assert.equal(threw, true);
     });
 
     it('Should serialize to MARCXML', () => {
@@ -68,15 +72,15 @@ describe('services/conversion', () => {
     it('Should rewrap a plain (non-ConversionError) serializer error into a ConversionError with 400', () => {
       // a plain {} makes MARCXML.to throw a TypeError, which serialize must
       // rewrap into a ConversionError 400 (not propagate the raw TypeError)
-      // eslint-disable-next-line functional/no-let
       let threw = false;
       try {
-        conversionService.serialize({}, CONVERSION_FORMATS.MARCXML);
+        conversionService.serialize({} as never, CONVERSION_FORMATS.MARCXML);
       } catch (error) {
         threw = true;
         assert(error instanceof ConversionError);
         assert.equal(error.status, 400);
-        assert.ok(error.payload.includes('Error while serializing record.'));
+        // the payload is a string here: 'Error while serializing record. ...'
+        assert.ok((error.payload as string).includes('Error while serializing record.'));
       }
       assert.equal(threw, true);
     });
@@ -85,11 +89,16 @@ describe('services/conversion', () => {
 
   describe('#unserialize', () => {
     it('Should throw because of unsupported format', () => {
+      let threw = false;
       try {
-        conversionService.unserialize();
+        // the undefined inputs are the point of this test: unserialize must
+        // throw a ConversionError for an unsupported format, not a TypeError
+        conversionService.unserialize(undefined as never, undefined as never);
       } catch (error) {
+        threw = true;
         assert(error instanceof ConversionError);
       }
+      assert.equal(threw, true);
     });
 
     it('Should unserialize from MARCXML', async () => {
@@ -114,11 +123,14 @@ describe('services/conversion', () => {
 
 
     it('Should throw because the record could not be unserialized', () => {
+      let threw = false;
       try {
         conversionService.unserialize('', CONVERSION_FORMATS.JSON);
       } catch (error) {
+        threw = true;
         assert(error instanceof ConversionError);
       }
+      assert.equal(threw, true);
     });
   });
 });

package/{tests/helpers/fix-edge.test.js → test/helpers/fix-edge.test.ts}

@@ -3,8 +3,9 @@
 import assert from 'node:assert';
 import {test} from 'node:test';
 import {MarcRecord} from '@natlibfi/marc-record';
-import {fixRecord} from '../../src/helpers/fix.js';
-import {BIB_STRIP_F884S_SETTINGS, BIB_F035_TO_SID} from '../../src/helpers/fix-constants.js';
+import type {MarcField} from '@natlibfi/marc-record';
+import {fixRecord} from '../../src/helpers/fix.ts';
+import {BIB_STRIP_F884S_SETTINGS, BIB_F035_TO_SID} from '../../src/helpers/fix-constants.ts';
 
 // a Melinda f884 (tag 884, $5 MELINDA, $a + $g present) that
 // has NO $k subfield. findSource/findHash used to call `sfK.replace(...)` on
@@ -52,7 +53,8 @@ test('fixRecord handles Melinda f884 without $k subfield without crashing', () =
   const result = fixRecord(record, BIB_STRIP_F884S_SETTINGS);
 
   // Both Melinda f884s survive (they are not identical, so uniq keeps both)
-  const f884s = result.fields.filter((f) => f.tag === '884');
+  // these are data fields: mirrors the JSDoc baseline MarcField[] cast
+  const f884s = (result.fields as MarcField[]).filter((f) => f.tag === '884');
   assert.equal(f884s.length, 2);
 
   // The field WITHOUT $k still has its $a, $g and $5 MELINDA
@@ -62,8 +64,8 @@ test('fixRecord handles Melinda f884 without $k subfield without crashing', () =
     noK.subfields.map((s) => s.code).sort(),
     ['5', 'a', 'g']
   );
-  const gNoK = noK.subfields.find((s) => s.code === 'g').value;
-  const aNoK = noK.subfields.find((s) => s.code === 'a').value;
+  const gNoK = noK.subfields.find((s) => s.code === 'g')?.value;
+  const aNoK = noK.subfields.find((s) => s.code === 'a')?.value;
   assert.equal(aNoK, 'ONIX3 to MARC transformation');
   assert.equal(gNoK, '20220101');
 
@@ -74,8 +76,8 @@ test('fixRecord handles Melinda f884 without $k subfield without crashing', () =
     withK.subfields.map((s) => s.code).sort(),
     ['5', 'a', 'g', 'k']
   );
-  assert.equal(withK.subfields.find((s) => s.code === 'g').value, '20000718');
-  assert.equal(withK.subfields.find((s) => s.code === 'k').value,
+  assert.equal(withK.subfields.find((s) => s.code === 'g')?.value, '20000718');
+  assert.equal(withK.subfields.find((s) => s.code === 'k')?.value,
     'SRC_4:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
 });
 
@@ -146,11 +148,12 @@ test('fixRecord ignores an existing SID field whose $b is not in fSIDFilters and
   }, {subfieldValues: false});
 
   const result = fixRecord(record, {generateMissingSIDs: BIB_F035_TO_SID});
-  const sids = result.fields.filter((f) => f.tag === 'SID');
+  // these are data fields: mirrors the JSDoc baseline MarcField[] cast
+  const sids = (result.fields as MarcField[]).filter((f) => f.tag === 'SID');
   assert.equal(sids.length, 2);
   const generated = sids.find((f) => f.subfields.some((s) => s.code === 'b' && s.value === 'FI-BTJ'));
   assert.ok(generated, 'a new SID with $b FI-BTJ should have been generated');
-  assert.equal(generated.subfields.find((s) => s.code === 'c').value, '12345');
+  assert.equal(generated.subfields.find((s) => s.code === 'c')?.value, '12345');
 });
 
 test('fixRecord ignores an existing SID field with a matching $b but missing $c and generates the SID from the f035', () => {
@@ -173,12 +176,13 @@ test('fixRecord ignores an existing SID field with a matching $b but missing $c
   }, {subfieldValues: false});
 
   const result = fixRecord(record, {generateMissingSIDs: BIB_F035_TO_SID});
-  const sids = result.fields.filter((f) => f.tag === 'SID');
+  // these are data fields: mirrors the JSDoc baseline MarcField[] cast
+  const sids = (result.fields as MarcField[]).filter((f) => f.tag === 'SID');
   assert.equal(sids.length, 2);
   const generated = sids.find((f) => f.subfields.some((s) => s.code === 'c'));
   assert.ok(generated, 'a generated SID with $c should exist');
-  assert.equal(generated.subfields.find((s) => s.code === 'b').value, 'FI-BTJ');
-  assert.equal(generated.subfields.find((s) => s.code === 'c').value, '12345');
+  assert.equal(generated.subfields.find((s) => s.code === 'b')?.value, 'FI-BTJ');
+  assert.equal(generated.subfields.find((s) => s.code === 'c')?.value, '12345');
 });
 
 test('fixRecord adds no SID when the f035 $a matches no f035Filter', () => {

package/{tests/helpers/fix.test.js → test/helpers/fix.test.ts}

@@ -1,15 +1,20 @@
 import assert from 'node:assert';
 import createDebugLogger from 'debug';
 import {MarcRecord} from '@natlibfi/marc-record';
+import type {MarcRecordObject} from '@natlibfi/marc-record';
 import {READERS} from '@natlibfi/fixura';
-import generateTests from '@natlibfi/fixugen';
-import {fixRecord} from '../../src/helpers/fix.js';
-import * as fixSettings from '../../src/helpers/fix-constants.js';
+import generateTests, {type CallbackArgs} from '@natlibfi/fixugen';
+import {fixRecord} from '../../src/helpers/fix.ts';
+import * as fixSettings from '../../src/helpers/fix-constants.ts';
+import type {FixSettings} from '../../src/helpers/fix-constants.ts';
 // import inspect from 'util';
 
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:fix:test');
 const debugData = debug.extend('data');
 
+// the settings names usable via metadata.json
+type SettingsKey = 'BIB_FORMAT_SETTINGS' | 'BIB_PREVALIDATION_FIX_SETTINGS' | 'BIB_POSTMERGE_FIX_SETTINGS' | 'BIB_PREIMPORT_FIX_SETTINGS' | 'AUTNAME_PREIMPORT_FIX_SETTINGS' | 'BIB_HANDLE_TEMP_URNS_SETTINGS' | 'BIB_STRIP_F884S_SETTINGS' | 'BIB_STRIP_F984S_SETTINGS' | 'BIB_STRIP_MELINDA_TEMP_SUBFIELDS_SETTINGS';
+
 generateTests({
   callback,
   path: [import.meta.dirname, '..', '..', 'test-fixtures', 'fix'],
@@ -21,15 +26,16 @@ generateTests({
   }
 });
 
-function callback({getFixture, settings = undefined}) {
+function callback(callbackParams: CallbackArgs) {
+  const {getFixture, settings = undefined} = callbackParams;
   if (
     settings !== undefined
     && typeof settings !== 'object'
-    && fixSettings[settings] === undefined
+    && (fixSettings[settings as SettingsKey]) === undefined
   ) {
     throw new Error(`There are no settings ${settings} defined!`);
   }
-  let runSettings = fixSettings[settings] || settings;
+  let runSettings: FixSettings | undefined = (fixSettings[settings as SettingsKey]) || (settings as FixSettings);
   // metadata.json is plain JSON, so f035Filters may contain string
   // patterns which fix.js cannot use as-is; convert them to RegExp
   if (runSettings && runSettings.generateMissingSIDs) {
@@ -38,14 +44,14 @@ function callback({getFixture, settings = undefined}) {
       generateMissingSIDs: {
         ...runSettings.generateMissingSIDs,
         f035Filters: (runSettings.generateMissingSIDs.f035Filters || []).map(
-          filter => (typeof filter === 'string' ? new RegExp(filter) : filter)
+          (filter): RegExp => (typeof filter === 'string' ? new RegExp(filter) : filter)
         ),
         fSIDFilters: runSettings.generateMissingSIDs.fSIDFilters
       }
     };
   }
 
-  const record = new MarcRecord(getFixture('record.json'), {subfieldValues: false});
+  const record = new MarcRecord(getFixture('record.json') as MarcRecordObject, {subfieldValues: false});
   const expectedRecord = getFixture('expectedRecord.json');
 
   debug(`Running fixer with settings ${settings}.`);

package/{tests/helpers/validation.test.js → test/helpers/validation.test.ts}

@@ -2,7 +2,9 @@ import assert from 'node:assert';
 import {describe, it} from 'node:test';
 import fixtureFactory, {READERS} from '@natlibfi/fixura';
 import {MarcRecord} from '@natlibfi/marc-record';
-import createValidator from '../../src/helpers/validation.js';
+import type {MarcRecordObject} from '@natlibfi/marc-record';
+
+import createValidator from '../../src/helpers/validation.ts';
 
 describe('services/validate', () => {
   const FIXTURES_PATH = [
@@ -22,14 +24,14 @@ describe('services/validate', () => {
           'in',
           'f003-fi-melinda.json'
         ]
-      }));
+      }) as MarcRecordObject);
       const result = await validator(record.toObject());
       const {record: expectedRecord, ...rest} = getFixture({
         components: [
           'out',
           'f003-fi-melinda.json'
         ]
-      });
+      }) as Record<string, any>;
       const {_validationOptions, ...expectedRecordData} = expectedRecord;
       const {record: actualRecord, ...actualRest} = result;
       assert.deepStrictEqual(actualRest, rest);
@@ -46,14 +48,14 @@ describe('services/validate', () => {
           'in',
           'f003-not-fi-melinda.json'
         ]
-      }));
+      }) as MarcRecordObject);
       const result = await validator(record.toObject());
       const {record: expectedRecord, ...rest} = getFixture({
         components: [
           'out',
           'f003-not-fi-melinda.json'
         ]
-      });
+      }) as Record<string, any>;
       const {_validationOptions, ...expectedRecordData} = expectedRecord;
       const {record: actualRecord, ...actualRest} = result;
       assert.deepStrictEqual(actualRest, rest);
@@ -62,4 +64,3 @@ describe('services/validate', () => {
     });
   });
 });
-

package/{tests/mongo-add-blob-size.test.js → test/mongo-add-blob-size.test.ts}

@@ -4,10 +4,10 @@ import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 //import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:add-blob-size:test');
 
 generateTests({
@@ -41,32 +41,31 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'add-blob-size'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-// eslint-disable-next-line max-statements, complexity
-async function callback({
-  getFixture,
-  functionName,
-  params,
-  expectModificationTime = false,
-  preFillDb = false,
-  expectedToThrow = false,
-  expectedErrorMessage = '',
-  expectedErrorStatus = ''
+async function callback(callbackParams: Record<string, any>) {
+  const {
+    getFixture,
+    functionName,
+    params,
+    expectModificationTime = false,
+    preFillDb = false,
+    expectedToThrow = false,
+    expectedErrorMessage = '',
+    expectedErrorStatus = ''
 
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;

package/{tests/mongo-check-and-check-state.test.js → test/mongo-check-and-check-state.test.ts}

@@ -4,10 +4,10 @@ import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 //import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test');
 
 generateTests({
@@ -41,14 +41,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -59,14 +59,14 @@ async function callback({
   expectedErrorStatus = '',
   expectedOpResult = undefined,
   updateStateBeforeTest = undefined
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;
@@ -81,7 +81,6 @@ async function callback({
       //{correlationId, state, errorMessage = undefined, errorStatus = undefined})
       // timeout
 
-      // eslint-disable-next-line functional/no-conditional-statements
       if (updateStateBeforeTest && params.correlationId) {
         debug(`setState to reset modificationTime`);
         await mongoOperator.setState({correlationId: params.correlationId, state: updateStateBeforeTest});
@@ -91,7 +90,6 @@ async function callback({
 
       // checkAndSetState now returns a discriminated result
       // {status: 'updated' | 'timeout' | 'unchanged', queueItem} - compare status
-      // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
         assert.deepStrictEqual(opResult.status, expectedOpResult);
       }

package/{tests/mongo-check-and-set-import-job-state.test.js → test/mongo-check-and-set-import-job-state.test.ts}

@@ -4,9 +4,9 @@ import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 //import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-and-set-import-job-state-test');
 
 generateTests({
@@ -40,15 +40,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-and-set-import-job-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-// eslint-disable-next-line max-statements, complexity
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -59,14 +58,14 @@ async function callback({
   expectedErrorStatus = '',
   expectedOpResult = undefined,
   updateStateBeforeTest = undefined
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;
@@ -81,7 +80,6 @@ async function callback({
       //{correlationId, operation, importJobState, errorMessage = '', errorStatus = ''}
       // timeout
 
-      // eslint-disable-next-line functional/no-conditional-statements
       if (updateStateBeforeTest && params.correlationId) {
         debug(`setState to reset modificationTime`);
         await mongoOperator.setState({correlationId: params.correlationId, state: updateStateBeforeTest});
@@ -91,7 +89,6 @@ async function callback({
 
       // checkAndSetImportJobState now returns a discriminated result
       // {status: 'updated' | 'timeout' | 'unchanged', queueItem} - compare status
-      // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
         assert.deepStrictEqual(opResult.status, expectedOpResult);
       }

package/{tests/mongo-check-timeout.test.js → test/mongo-check-timeout.test.ts}

@@ -4,10 +4,10 @@ import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 //import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-timeout:test');
 
 generateTests({
@@ -41,15 +41,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'check-timeout'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-// eslint-disable-next-line max-statements, complexity
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -60,14 +59,14 @@ async function callback({
   expectedErrorStatus = '',
   expectedOpResult = undefined,
   updateStateBeforeTest = undefined
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;
@@ -81,7 +80,6 @@ async function callback({
       debug(JSON.stringify(params));
       //{correlationId}
       // timeout
-      // eslint-disable-next-line functional/no-conditional-statements
       if (updateStateBeforeTest && params.correlationId) {
         debug(`setState to reset modificationTime`);
         await mongoOperator.setState({correlationId: params.correlationId, state: updateStateBeforeTest});
@@ -89,7 +87,6 @@ async function callback({
       const opResult = await mongoOperator.checkTimeOut(params);
       debug(`checkTimeOut result: ${JSON.stringify(opResult)} (it should be: ${JSON.stringify(expectedOpResult)})}`);
 
-      // eslint-disable-next-line functional/no-conditional-statements
       if (expectedOpResult !== undefined) {
         assert.deepStrictEqual(opResult, expectedOpResult);
       }

package/{tests/mongo-create-bulk.test.js → test/mongo-create-bulk.test.ts}

@@ -3,9 +3,9 @@ import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 //import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test:create-bulk');
 
 generateTests({
@@ -39,15 +39,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'create-bulk'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-// eslint-disable-next-line max-statements, complexity
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -57,14 +56,14 @@ async function callback({
   expectedErrorStatus = '',
   contentStream = false,
   expectedFileCount = undefined
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;

package/{tests/mongo-create-prio.test.js → test/mongo-create-prio.test.ts}

@@ -3,10 +3,10 @@ import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 // import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:create-prio-test');
 
 generateTests({
@@ -40,14 +40,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'create-prio'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -55,14 +55,14 @@ async function callback({
   expectedToThrow = false,
   expectedErrorMessage = '',
   expectedErrorStatus = ''
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;