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

package/{tests/amqp.tests.localtest.js → test/amqp.tests.localtest.ts}

@@ -3,8 +3,11 @@ import createDebugLogger from 'debug';
 import {promisify} from 'util';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
+import type {CallbackArgs} from '@natlibfi/fixugen';
 import {Error as ApiError} from '@natlibfi/melinda-commons';
-import {amqpFactory} from '../src/index.js';
+import type {GetMessage, Message} from 'amqplib';
+import {amqpFactory} from '../src/index.ts';
+import type {AmqpOperator, QueueItemMessagePayload, QueueItemRecordPayload, SendToQueueParams} from '../src/amqp.ts';
 
 const setTimeoutPromise = promisify(setTimeout);
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
@@ -18,8 +21,7 @@ const testData = {
 
 debug(`Testing amqp against a local AMQP instance - we'll need some kind of mockup for this`);
 const amqpUrl = 'amqp://127.0.0.1:5672/';
-// eslint-disable-next-line functional/no-let
-let amqpOperator;
+let amqpOperator: AmqpOperator;
 
 generateTests({
   callback,
@@ -48,8 +50,15 @@ generateTests({
   }
 });
 
-// eslint-disable-next-line max-statements
-async function callback({
+/**
+ * One fixture case. See the fixture metadata files in test-fixtures/amqp
+ * for the possible keys (getFixture, expectToFail, expectedErrorStatus,
+ * ackMessages, nackMessages, checkNextMessage, checkQueueStyle, queue,
+ * sentToQueue, expectedMessageCount, removeQueue, expectedErrorMessage,
+ * expectApiError, expectFalseCheckResult).
+ */
+async function callback(callbackParams: CallbackArgs) {
+  const {
   getFixture,
   expectToFail = false,
   expectedErrorStatus = '',
@@ -57,14 +66,16 @@ async function callback({
   nackMessages = false,
   checkNextMessage = false,
   checkQueueStyle = false,
-  queue = testData.queue,
+  queue: queueFromFixture = testData.queue,
   sentToQueue,
   expectedMessageCount,
   removeQueue = false,
   expectedErrorMessage = undefined,
   expectApiError = false,
   expectFalseCheckResult = false
-}) {
+  } = callbackParams;
+  // the fixture contract passes the queue name as a string
+  const queue = queueFromFixture as string;
   try {
     await sendMessagesToQueue();
 
@@ -79,7 +90,7 @@ async function callback({
     assert.equal(messageCount, expectedMessageCount);
 
     if (checkNextMessage) {
-      const {headers, records} = await queueCheckNextMessage();
+      const {headers, records} = (await queueCheckNextMessage()) as QueueItemRecordPayload;
       const nextMessage = {headers, records};
       const expectedNextMessage = getFixture('expectedMessage.json');
       assert.deepStrictEqual(
@@ -97,15 +108,19 @@ async function callback({
     testErrors(error);
   }
 
-  function testErrors(error) {
+  /**
+   * @param error
+   */
+  function testErrors(error: unknown) {
     const isApiError = error instanceof ApiError;
     if (expectApiError) {
       assert.equal(isApiError, true);
       debug(`We expected and got an ApiError`);
-      assert.equal(error.status, expectedErrorStatus);
+      const apiError = error as ApiError;
+      assert.equal(apiError.status, expectedErrorStatus);
 
       if (expectedErrorMessage) {
-        assert.equal(error.payload, expectedErrorMessage);
+        assert.equal(apiError.payload, expectedErrorMessage);
         return;
       }
 
@@ -113,26 +128,26 @@ async function callback({
     }
     assert.equal(isApiError, false);
     debug(`We expected and got an non-ApiError`);
-    debug(`Error is a ${error.constructor.name}`);
+    const maybeError = error as Error;
+    debug(`Error is a ${maybeError.constructor.name}`);
   }
 
   function queueRemoval() {
     if (removeQueue) {
-      return amqpOperator.removeQueue(removeQueue);
+      return amqpOperator.removeQueue(removeQueue as string);
     }
 
     return;
   }
 
-  function queueCheckNextMessage() {
+  function queueCheckNextMessage(): Promise<QueueItemRecordPayload> | false {
     if (checkNextMessage) {
-      return amqpOperator.consumeOne(testData.queue, true);
+      return amqpOperator.consumeOne(testData.queue, true) as Promise<QueueItemRecordPayload>;
     }
 
     return false;
   }
 
-  // eslint-disable-next-line max-statements
   async function checkQueue() {
     debug(`checkQueueStyle: ${checkQueueStyle}`);
 
@@ -144,18 +159,19 @@ async function callback({
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'records'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.records.length, 1);
-      assert.equal(result.messages.length, 1);
+      const recordResult = result as QueueItemRecordPayload;
+      assert.equal(Object.hasOwn(recordResult, 'headers'), true);
+      assert.equal(Object.hasOwn(recordResult, 'records'), true);
+      assert.equal(Object.hasOwn(recordResult, 'messages'), true);
+      assert.equal(recordResult.records.length, 1);
+      assert.equal(recordResult.messages.length, 1);
 
       return;
     }
 
     if (checkQueueStyle === 'oneNotRecord') {
       const result = await amqpOperator.checkQueue({queue, style: 'one', toRecord: false, purge: false});
-      const {fields} = result;
+      const {fields} = result as GetMessage;
 
       if (expectFalseCheckResult) {
         assert.strictEqual(result, false);
@@ -178,14 +194,15 @@ async function callback({
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'records'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.records.length, 3);
-      assert.equal(result.messages.length, 3);
+      const recordResult = result as QueueItemRecordPayload;
+      assert.equal(Object.hasOwn(recordResult, 'headers'), true);
+      assert.equal(Object.hasOwn(recordResult, 'records'), true);
+      assert.equal(Object.hasOwn(recordResult, 'messages'), true);
+      assert.equal(recordResult.records.length, 3);
+      assert.equal(recordResult.messages.length, 3);
       const expectedResult = getFixture('expectedResult.json');
       assert.deepStrictEqual(
-        JSON.parse(JSON.stringify(result.records)),
+        JSON.parse(JSON.stringify(recordResult.records)),
         expectedResult,
       );
 
@@ -200,11 +217,13 @@ async function callback({
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.messages.length, 3);
+      const messageResult = result as QueueItemMessagePayload;
+      assert.equal(Object.hasOwn(messageResult, 'headers'), true);
+      assert.equal(Object.hasOwn(messageResult, 'messages'), true);
+      assert.equal(messageResult.messages.length, 3);
 
-      const [{fields}] = result.messages;
+      const [firstMessage] = messageResult.messages as [Message, ...Message[]];
+      const {fields} = firstMessage;
 
       assert.equal(typeof fields.deliveryTag, 'number');
       assert.equal(typeof fields.messageCount, 'number');
@@ -228,14 +247,14 @@ async function callback({
   async function ackOrNackMessages() {
     if (ackMessages) {
       const message = await amqpOperator.consumeOne(testData.queue, false);
-      await amqpOperator.ackMessages([message]);
+      await amqpOperator.ackMessages([message as GetMessage]);
 
       return setTimeoutPromise(10);
     }
 
     if (nackMessages) {
       const message = await amqpOperator.consumeOne(testData.queue, false);
-      await amqpOperator.nackMessages([message]);
+      await amqpOperator.nackMessages([message as GetMessage]);
 
       return setTimeoutPromise(10);
     }
@@ -245,7 +264,7 @@ async function callback({
 
   async function sendMessagesToQueue() {
     if (sentToQueue) {
-      const messages = getFixture('input.json');
+      const messages = getFixture('input.json') as SendToQueueParams[];
       // {queue, correlationId, headers, data}
 
       const promises = messages.map(message => amqpOperator.sendToQueue(message));

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