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

package/{tests/mongo-error-branches.test.js → test/mongo-error-branches.test.ts}

@@ -1,17 +1,19 @@
-
 import assert from 'node:assert';
 import {test} from 'node:test';
 import {Readable, PassThrough} from 'node:stream';
 import httpStatus from 'http-status';
 import {MongoDriverError} from 'mongodb';
 import {Error as ApiError} from '@natlibfi/melinda-commons';
-import createMongo from '../src/mongo.js';
-import createMongoLog from '../src/mongoLog.js';
+import createMongo from '../src/mongo.ts';
+import createMongoLog from '../src/mongoLog.ts';
 
 const DUMMY_URI = 'mongodb://stub:27017/rest-api';
 const COLLECTION = 'foobar';
 
-function makeOperator(overrides = {}) {
+// the deps seam takes unknown-typed dependencies, so plain stub objects
+// are fine to inject (the driver types are never exercised here)
+
+function makeOperator(overrides: Record<string, any> = {}) {
   return {
     insertOne: async () => ({acknowledged: true, insertedId: 1}),
     deleteOne: async () => ({acknowledged: true, deletedCount: 1}),
@@ -19,7 +21,7 @@ function makeOperator(overrides = {}) {
   };
 }
 
-function makeGridFSBucket(overrides = {}) {
+function makeGridFSBucket(overrides: Record<string, any> = {}) {
   return {
     find: () => ({toArray: async () => []}),
     openDownloadStreamByName: () => {
@@ -29,10 +31,18 @@ function makeGridFSBucket(overrides = {}) {
   };
 }
 
-async function makeMongo(deps) {
+/**
+ * @param deps the injected stub operator/gridFSBucket
+ */
+async function makeMongo(deps: Record<string, any>) {
   return createMongo(DUMMY_URI, COLLECTION, 'rest-api', deps);
 }
 
+// The 400-guard tests pass intentionally malformed inputs (non-string
+// correlationId, non-array ids, ...) that break the operator param types on
+// purpose; this helper bypasses the type check for those objects
+const asMalformed = <T>(params: any): T => params as T;
+
 test('createPrio: insertOne with acknowledged=false throws ApiError 500', async () => {
   const mongo = await makeMongo({
     operator: makeOperator({insertOne: async () => ({acknowledged: false})}),
@@ -60,7 +70,7 @@ test('createPrio: insertOne rejecting throws ApiError 500 with "Mongo errored" m
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('Mongo errored'));
+      assert.ok((error.payload as string).includes('Mongo errored'));
       return true;
     }
   );
@@ -105,13 +115,12 @@ test('remove: MongoDriverError "File not found" deletes queueItem and reports wh
 });
 
 test('remove: returns {removed: true, deletedContent: true} when the queueItem and its GridFS file both exist', async () => {
-  const deletedFiles = [];
+  const deletedFiles: any[] = [];
   const mongo = await makeMongo({
     operator: makeOperator({deleteOne: async () => ({acknowledged: true, deletedCount: 1})}),
     gridFSBucket: makeGridFSBucket({
       find: () => ({toArray: async () => [{_id: 'file-1', filename: 'FOO'}]}),
-      delete: async (id) => {
-        // eslint-disable-next-line functional/immutable-data
+      delete: async (id: unknown) => {
         deletedFiles.push(id);
         return true;
       }
@@ -147,7 +156,7 @@ test('remove: MongoDriverError with other message throws ApiError 500', async ()
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('some other driver error'));
+      assert.ok((error.payload as string).includes('some other driver error'));
       return true;
     }
   );
@@ -190,7 +199,7 @@ test('getStream rejects with ApiError 500 when openDownloadStreamByName throws',
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('Mongo errored'));
+      assert.ok((error.payload as string).includes('Mongo errored'));
       return true;
     }
   );
@@ -276,22 +285,27 @@ test('createBulk (stream) returns the normalized {correlationId, acknowledged, q
 });
 
 test('checkTimeOut honours MONGO_TIMEOUT_MINUTES (older item than the window is aborted)', async () => {
-  process.env.MONGO_TIMEOUT_MINUTES = '5';
-  const oldDate = new Date(Date.now() - 4 * 60 * 1000); // 4 min old: fine at 5m, not at 1m
-  const mongo = await makeMongo({
-    operator: makeOperator({
-      findOne: async () => ({
-        correlationId: 'FOO',
-        queueItemState: 'VALIDATING',
-        modificationTime: oldDate,
-        importJobState: {CREATE: 'DONE', UPDATE: 'DONE', FIX: 'DONE'}
-      })
-    }),
-    gridFSBucket: makeGridFSBucket()
-  });
-  const result = await mongo.checkTimeOut({correlationId: 'FOO'});
-  delete process.env.MONGO_TIMEOUT_MINUTES;
-  assert.equal(result, true);
+  process.env['MONGO_TIMEOUT_MINUTES'] = '5';
+  try {
+    const oldDate = new Date(Date.now() - 4 * 60 * 1000); // 4 min old: fine at 5m, not at 1m
+    const mongo = await makeMongo({
+      operator: makeOperator({
+        findOne: async () => ({
+          correlationId: 'FOO',
+          queueItemState: 'VALIDATING',
+          modificationTime: oldDate,
+          importJobState: {CREATE: 'DONE', UPDATE: 'DONE', FIX: 'DONE'}
+        })
+      }),
+      gridFSBucket: makeGridFSBucket()
+    });
+    const result = await mongo.checkTimeOut({correlationId: 'FOO'});
+    assert.equal(result, true);
+  } finally {
+    // restore the env even on failure so a later operator does not inherit a
+    // 5-minute timeout window
+    delete process.env['MONGO_TIMEOUT_MINUTES'];
+  }
 });
 
 // createBulk stream path used to have no error handling on the GridFS
@@ -299,7 +313,7 @@ test('checkTimeOut honours MONGO_TIMEOUT_MINUTES (older item than the window is
 // (orphan partial chunks). Both are now wired to reject + cleanup.
 
 test('createBulk rejects with ApiError 500 when input stream errors mid-upload, and cleans up the partial file', async () => {
-  const deletedFiles = [];
+  const deletedFiles: any[] = [];
   // errors itself once flowing mode starts
   const input = new Readable({
     read() {
@@ -311,8 +325,7 @@ test('createBulk rejects with ApiError 500 when input stream errors mid-upload,
     gridFSBucket: makeGridFSBucket({
       openUploadStream: () => new PassThrough(),
       find: () => ({toArray: async () => [{_id: 'partial-1', filename: 'FOO'}]}),
-      delete: async (id) => {
-        // eslint-disable-next-line functional/immutable-data
+      delete: async (id: unknown) => {
         deletedFiles.push(id);
         return true;
       }
@@ -331,7 +344,7 @@ test('createBulk rejects with ApiError 500 when input stream errors mid-upload,
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('input stream boom'));
+      assert.ok((error.payload as string).includes('input stream boom'));
       return true;
     }
   );
@@ -363,7 +376,7 @@ test('createBulk rejects with ApiError 500 when the GridFS output stream errors
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('disk on fire'));
+      assert.ok((error.payload as string).includes('disk on fire'));
       return true;
     }
   );
@@ -375,7 +388,8 @@ test('createBulk rejects with ApiError 500 when the GridFS output stream errors
 test('pushIds rejects with ApiError 400 when handledIds is not an array', async () => {
   const mongo = await makeMongo({operator: makeOperator(), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.pushIds({correlationId: 'FOO', handledIds: 'nope', rejectedIds: []}),
+    // intentionally malformed input: handledIds must be string[]
+    () => mongo.pushIds(asMalformed({correlationId: 'FOO', handledIds: 'nope', rejectedIds: []})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -387,7 +401,8 @@ test('pushIds rejects with ApiError 400 when handledIds is not an array', async
 test('pushIds rejects with ApiError 400 when rejectedIds is not an array', async () => {
   const mongo = await makeMongo({operator: makeOperator(), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.pushIds({correlationId: 'FOO', handledIds: [], rejectedIds: undefined}),
+    // intentionally malformed input: rejectedIds must be string[]
+    () => mongo.pushIds(asMalformed({correlationId: 'FOO', handledIds: [], rejectedIds: undefined})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -408,8 +423,8 @@ test('pushIds rejects with ApiError 500 "Mongo errored" when updateOne throws',
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('Mongo errored'));
-      assert.ok(error.payload.includes('pushIds boom'));
+      assert.ok((error.payload as string).includes('Mongo errored'));
+      assert.ok((error.payload as string).includes('pushIds boom'));
       return true;
     }
   );
@@ -418,7 +433,8 @@ test('pushIds rejects with ApiError 500 "Mongo errored" when updateOne throws',
 test('pushMessages rejects with ApiError 400 when messages is not an array', async () => {
   const mongo = await makeMongo({operator: makeOperator(), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.pushMessages({correlationId: 'FOO', messages: 'nope'}),
+    // intentionally malformed input: messages must be an array
+    () => mongo.pushMessages(asMalformed({correlationId: 'FOO', messages: 'nope'})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -439,8 +455,8 @@ test('pushMessages rejects with ApiError 500 "Mongo errored" when updateOne thro
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('Mongo errored'));
-      assert.ok(error.payload.includes('pushMessages boom'));
+      assert.ok((error.payload as string).includes('Mongo errored'));
+      assert.ok((error.payload as string).includes('pushMessages boom'));
       return true;
     }
   );
@@ -452,7 +468,8 @@ test('pushMessages rejects with ApiError 500 "Mongo errored" when updateOne thro
 test('checkAndSetState rejects with ApiError 400 when correlationId is not a string', async () => {
   const mongo = await makeMongo({operator: makeOperator(), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.checkAndSetState({correlationId: {'$ne': ''}, state: 'VALIDATING'}),
+    // intentionally malformed input: correlationId must be a string
+    () => mongo.checkAndSetState(asMalformed({correlationId: {'$ne': ''}, state: 'VALIDATING'})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -464,7 +481,8 @@ test('checkAndSetState rejects with ApiError 400 when correlationId is not a str
 test('getOne rejects with ApiError 400 when queueItemState is not a string', async () => {
   const mongo = await makeMongo({operator: makeOperator({findOne: async () => null}), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.getOne({queueItemState: {'$ne': ''}}),
+    // intentionally malformed input: queueItemState must be a string
+    () => mongo.getOne(asMalformed({queueItemState: {'$ne': ''}})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -476,7 +494,8 @@ test('getOne rejects with ApiError 400 when queueItemState is not a string', asy
 test('getOne rejects with ApiError 400 when importJobState is not an object', async () => {
   const mongo = await makeMongo({operator: makeOperator({findOne: async () => null}), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.getOne({importJobState: 'IN_QUEUE'}),
+    // intentionally malformed input: importJobState must be an object
+    () => mongo.getOne(asMalformed({importJobState: 'IN_QUEUE'})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -510,10 +529,9 @@ test('getOne rejects with ApiError 400 when an importJobState value is not a str
 });
 
 test('getOne queries findOne with a valid importJobState filter', async () => {
-  const filters = [];
+  const filters: any[] = [];
   const mongo = await makeMongo({
-    operator: makeOperator({findOne: async (filter) => {
-      // eslint-disable-next-line functional/immutable-data
+    operator: makeOperator({findOne: async (filter: unknown) => {
       filters.push(filter);
       return null;
     }}),
@@ -527,7 +545,8 @@ test('getOne queries findOne with a valid importJobState filter', async () => {
 test('setBlobSize rejects with ApiError 400 when blobSize is not a number', async () => {
   const mongo = await makeMongo({operator: makeOperator(), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.setBlobSize({correlationId: 'FOO', blobSize: '7'}),
+    // intentionally malformed input: blobSize must be a number
+    () => mongo.setBlobSize(asMalformed({correlationId: 'FOO', blobSize: '7'})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -537,10 +556,9 @@ test('setBlobSize rejects with ApiError 400 when blobSize is not a number', asyn
 });
 
 test('setBlobSize stores a real number when blobSize is a number', async () => {
-  const updates = [];
+  const updates: any[] = [];
   const mongo = await makeMongo({
-    operator: makeOperator({findOneAndUpdate: async (filter, update) => {
-      // eslint-disable-next-line functional/immutable-data
+    operator: makeOperator({findOneAndUpdate: async (filter: unknown, update: unknown) => {
       updates.push({filter, update});
       return {correlationId: 'FOO', blobSize: 7};
     }}),
@@ -555,7 +573,8 @@ test('setBlobSize stores a real number when blobSize is a number', async () => {
 test('pushMessages rejects with ApiError 400 when messageField is not a string', async () => {
   const mongo = await makeMongo({operator: makeOperator(), gridFSBucket: makeGridFSBucket()});
   await assert.rejects(
-    () => mongo.pushMessages({correlationId: 'FOO', messages: ['m1'], messageField: 42}),
+    // intentionally malformed input: messageField must be a string
+    () => mongo.pushMessages(asMalformed({correlationId: 'FOO', messages: ['m1'], messageField: 42})),
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.BAD_REQUEST);
@@ -588,7 +607,7 @@ test('createBulk (stream): insertOne with acknowledged=false throws ApiError 500
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('Mongo errored'));
+      assert.ok((error.payload as string).includes('Mongo errored'));
       return true;
     }
   );
@@ -625,8 +644,8 @@ test('createBulk (stream): a failing GridFS cleanup does not mask the original u
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('input stream boom'));
-      assert.ok(!error.payload.includes('gridfs cleanup boom'));
+      assert.ok((error.payload as string).includes('input stream boom'));
+      assert.ok(!(error.payload as string).includes('gridfs cleanup boom'));
       return true;
     }
   );
@@ -644,7 +663,7 @@ test('remove: non-MongoDriverError from deleteOne throws ApiError 500 with the e
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-      assert.ok(error.payload.includes('plain delete boom'));
+      assert.ok((error.payload as string).includes('plain delete boom'));
       return true;
     }
   );
@@ -663,18 +682,62 @@ test('setOperation rejects with ApiError 404 when findOneAndUpdate returns null'
     (error) => {
       assert.ok(error instanceof ApiError);
       assert.equal(error.status, httpStatus.NOT_FOUND);
-      assert.ok(error.payload.message.includes('not found'));
+      assert.ok((error.payload as {message: string}).message.includes('not found'));
       return true;
     }
   );
 });
 
+// Q-3: previously-unwrapped public methods now reject with ApiError 500
+// ("Mongo errored: ...") when the driver fails, instead of leaking the raw
+// MongoDriverError. Non-driver errors (400/404 ApiErrors) still pass
+// through unchanged.
+
+test('mongo query: MongoDriverError from find rejects with ApiError 500 "Mongo errored"', async () => {
+  const mongo = await makeMongo({
+    operator: makeOperator({find: () => {
+      throw new MongoDriverError('query driver boom');
+    }}),
+    gridFSBucket: makeGridFSBucket()
+  });
+  await assert.rejects(
+    () => mongo.query({}),
+    mongoErrored500('query driver boom')
+  );
+});
+
+test('mongo queryById: MongoDriverError from findOne rejects with ApiError 500 "Mongo errored"', async () => {
+  const mongo = await makeMongo({
+    operator: makeOperator({findOne: async () => {
+      throw new MongoDriverError('queryById driver boom');
+    }}),
+    gridFSBucket: makeGridFSBucket()
+  });
+  await assert.rejects(
+    () => mongo.queryById({correlationId: 'FOO'}),
+    mongoErrored500('queryById driver boom')
+  );
+});
+
+test('mongo checkTimeOut: MongoDriverError from findOne rejects with ApiError 500 "Mongo errored"', async () => {
+  const mongo = await makeMongo({
+    operator: makeOperator({findOne: async () => {
+      throw new MongoDriverError('checkTimeOut driver boom');
+    }}),
+    gridFSBucket: makeGridFSBucket()
+  });
+  await assert.rejects(
+    () => mongo.checkTimeOut({correlationId: 'FOO'}),
+    mongoErrored500('checkTimeOut driver boom')
+  );
+});
+
 // mongoLog: same deps-seam convention as mongo (factory last param). When
 // deps.collection is provided no real connection is made and every
 // db.collection('logs') call routes to the injected object. These tests
 // cover the catch blocks that re-wrap driver failures as ApiError 500.
 
-function makeLogCollection(overrides = {}) {
+function makeLogCollection(overrides: Record<string, any> = {}) {
   return {
     insertOne: async () => ({acknowledged: true, insertedId: 1}),
     updateMany: async () => ({acknowledged: true, matchedCount: 0, modifiedCount: 0}),
@@ -683,16 +746,19 @@ function makeLogCollection(overrides = {}) {
   };
 }
 
-async function makeMongoLog(deps) {
+/**
+ * @param deps the injected stub collection
+ */
+async function makeMongoLog(deps: Record<string, any>) {
   return createMongoLog(DUMMY_URI, 'rest-api', deps);
 }
 
-function mongoErrored500(text) {
-  return (error) => {
+function mongoErrored500(text: string) {
+  return (error: unknown) => {
     assert.ok(error instanceof ApiError);
     assert.equal(error.status, httpStatus.INTERNAL_SERVER_ERROR);
-    assert.ok(error.payload.includes('Mongo errored'));
-    assert.ok(error.payload.includes(text));
+    assert.ok((error.payload as string).includes('Mongo errored'));
+    assert.ok((error.payload as string).includes(text));
     return true;
   };
 }
@@ -723,6 +789,42 @@ test('mongoLog addLogItem: insertOne rejecting throws ApiError 500 with "Mongo e
   );
 });
 
+test('mongoLog query: MongoDriverError from find rejects with ApiError 500 "Mongo errored"', async () => {
+  const mongoLog = await makeMongoLog({
+    collection: makeLogCollection({find: () => {
+      throw new MongoDriverError('mongoLog query driver boom');
+    }})
+  });
+  await assert.rejects(
+    () => mongoLog.query({}),
+    mongoErrored500('mongoLog query driver boom')
+  );
+});
+
+test('mongoLog queryById: MongoDriverError from find rejects with ApiError 500 "Mongo errored"', async () => {
+  const mongoLog = await makeMongoLog({
+    collection: makeLogCollection({find: () => {
+      throw new MongoDriverError('mongoLog queryById driver boom');
+    }})
+  });
+  await assert.rejects(
+    () => mongoLog.queryById('FOO'),
+    mongoErrored500('mongoLog queryById driver boom')
+  );
+});
+
+test('mongoLog getListOfCatalogers: MongoDriverError from distinct rejects with ApiError 500 "Mongo errored"', async () => {
+  const mongoLog = await makeMongoLog({
+    collection: makeLogCollection({distinct: async () => {
+      throw new MongoDriverError('mongoLog distinct driver boom');
+    }})
+  });
+  await assert.rejects(
+    () => mongoLog.getListOfCatalogers(),
+    mongoErrored500('mongoLog distinct driver boom')
+  );
+});
+
 test('mongoLog protect: updateMany rejecting throws ApiError 500 with "Mongo errored" message', async () => {
   const mongoLog = await makeMongoLog({
     collection: makeLogCollection({updateMany: async () => {
@@ -772,11 +874,10 @@ test('mongoLog removeBySequences: deleteMany rejecting throws ApiError 500 with
 });
 
 test('mongoLog protect: injected collection routes the update and returns its result', async () => {
-  const filters = [];
+  const filters: any[] = [];
   const result = {acknowledged: true, matchedCount: 1, modifiedCount: 1};
   const mongoLog = await makeMongoLog({
-    collection: makeLogCollection({updateMany: async (filter) => {
-      // eslint-disable-next-line functional/immutable-data
+    collection: makeLogCollection({updateMany: async (filter: unknown) => {
       filters.push(filter);
       return result;
     }})

package/{tests/mongo-get-one.test.js → test/mongo-get-one.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} from './testUtils.js';
+import {getMongoOperator, handleError} from './testUtils.ts';
 
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-one:test');
 
 generateTests({
@@ -41,14 +41,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'get-one'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -57,14 +57,14 @@ async function callback({
   expectedErrorMessage = '',
   expectedErrorStatus = '',
   expectedOpResult = 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-get-stream.test.js → test/mongo-get-stream.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, streamToString} from './testUtils.js';
+import {getMongoOperator, handleError, streamToString} from './testUtils.ts';
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-stream:test');
 
 generateTests({
@@ -40,15 +40,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'get-stream'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-// eslint-disable-next-line max-statements
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -58,14 +57,14 @@ async function callback({
   expectedErrorStatus = '',
   contentStream = false,
   createBulkParams = 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;
@@ -80,7 +79,6 @@ async function callback({
       debug(JSON.stringify(params));
       //correlationId
 
-      // eslint-disable-next-line functional/no-conditional-statements
       if (createBulkParams) {
         const stream = contentStream ? await getFixture({components: ['contentStream'], reader: READERS.STREAM}) : createBulkParams.stream;
         //debug(stream);

package/{tests/mongo-push-ids.test.js → test/mongo-push-ids.test.ts}

@@ -3,10 +3,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:push-ids:test');
 
 generateTests({
@@ -40,14 +40,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'push-ids'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -56,14 +56,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;

package/{tests/mongo-push-messages.test.js → test/mongo-push-messages.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:push-messages:test');
 
 generateTests({
@@ -40,14 +40,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'push-messages'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -56,14 +56,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;