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

package/dist/mongo.js

@@ -1,486 +1,625 @@
-import { MongoClient, GridFSBucket, MongoDriverError } from "mongodb";
-import moment from "moment";
-import httpStatus from "http-status";
-import sanitize from "mongo-sanitize";
-import createDebugLogger from "debug";
-import { createLogger } from "@natlibfi/melinda-backend-commons";
-import { Error as ApiError, parseBoolean } from "@natlibfi/melinda-commons";
+import { MongoClient, GridFSBucket, MongoDriverError } from 'mongodb';
+import httpStatus from 'http-status';
+import createDebugLogger from 'debug';
+import { createLogger, Error as ApiError, parseBoolean } from '@natlibfi/melinda-commons';
 import { QUEUE_ITEM_STATE, IMPORT_JOB_STATE, OPERATIONS } from "./constants.js";
-import { logError } from "./utils.js";
-export default async function(MONGO_URI, collection, db = "rest-api") {
-  const logger = createLogger();
-  const debug = createDebugLogger("@natlibfi/melinda-rest-api-commons/mongo");
-  const debugDev = debug.extend(":dev");
-  const client = await MongoClient.connect(MONGO_URI);
-  const dbConnection = client.db(db);
-  const gridFSBucket = new GridFSBucket(dbConnection, { bucketName: collection });
-  const operator = dbConnection.collection(collection);
-  debugDev(`mongo: ${MONGO_URI}, db: ${db}, collection: ${collection}`);
-  return { createPrio, createBulk, checkAndSetState, checkAndSetImportJobState, query, createProjection, queryById, checkTimeOut, remove, readContent, removeContent, getOne, getStream, setState, setImportJobState, pushIds, pushMessages, setOperation, setOperations, addBlobSize, setBlobSize };
-  async function createPrio({ correlationId, cataloger, oCatalogerIn, operation, operationSettings }) {
-    debugDev("createPrio");
-    const time = moment().toDate();
-    const newQueueItem = {
-      correlationId,
-      cataloger,
-      operation,
-      operations: [operation],
-      oCatalogerIn,
-      operationSettings: {
-        prio: true,
-        ...operationSettings
-      },
-      queueItemState: QUEUE_ITEM_STATE.VALIDATOR.PENDING_VALIDATION,
-      blobSize: 1,
-      importJobState: {
-        CREATE: IMPORT_JOB_STATE.EMPTY,
-        UPDATE: IMPORT_JOB_STATE.EMPTY,
-        FIX: IMPORT_JOB_STATE.EMPTY
-      },
-      records: [],
-      errorMessage: "",
-      errorStatus: "",
-      creationTime: time,
-      modificationTime: time
-    };
-    try {
-      debugDev(`Inserting: ${JSON.stringify(newQueueItem)} to ${collection}}`);
-      const result = await operator.insertOne(newQueueItem);
-      debugDev(JSON.stringify(result));
-      if (result.acknowledged) {
-        logger.info(`New PRIO queue item for ${operation} ${correlationId} has been made in ${collection}`);
-        return;
-      }
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR);
-    } catch (error) {
-      const errorMessage = error.payload || error.message || "";
-      logError(error);
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+import { logError, assertString, assertNumber, assertImportJobStateFilter } from "./utils.js";
+import { withMongoError } from "./mongoError.js";
+export default async function (MONGO_URI, collection, db = 'rest-api', deps = {}) {
+    const logger = createLogger();
+    const timeoutMinutes = Number.parseInt(process.env['MONGO_TIMEOUT_MINUTES'], 10) || 1;
+    logger.debug(`checkTimeOut window: ${timeoutMinutes} minute(s) (override with MONGO_TIMEOUT_MINUTES)`);
+    const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo');
+    const debugDev = debug.extend(':dev');
+    const stubbed = Boolean(deps.operator) && Boolean(deps.gridFSBucket);
+    let gridFSBucket = deps.gridFSBucket;
+    let operator = deps.operator;
+    if (!stubbed) {
+        const client = await MongoClient.connect(MONGO_URI);
+        const realDb = client.db(db);
+        gridFSBucket = gridFSBucket ?? new GridFSBucket(realDb, { bucketName: collection });
+        operator = operator ?? realDb.collection(collection);
     }
-  }
-  async function createBulk({ correlationId, cataloger, oCatalogerIn, operation, contentType, recordLoadParams, stream, operationSettings }) {
-    const time = moment().toDate();
-    const newQueueItem = {
-      correlationId,
-      cataloger,
-      oCatalogerIn,
-      operation,
-      operations: [operation],
-      operationSettings: {
-        prio: false,
-        ...operationSettings
-      },
-      contentType,
-      recordLoadParams,
-      queueItemState: stream ? QUEUE_ITEM_STATE.VALIDATOR.UPLOADING : QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS,
-      blobSize: 0,
-      importJobState: {
-        CREATE: IMPORT_JOB_STATE.EMPTY,
-        UPDATE: IMPORT_JOB_STATE.EMPTY,
-        FIX: IMPORT_JOB_STATE.EMPTY
-      },
-      records: [],
-      errorMessage: "",
-      errorStatus: "",
-      creationTime: time,
-      modificationTime: time
+    debugDev(`mongo: ${MONGO_URI}, db: ${db}, collection: ${collection}`);
+    return {
+        createPrio,
+        createBulk,
+        checkAndSetState: (params) => withMongoError(() => checkAndSetState(params)),
+        checkAndSetImportJobState: (params) => withMongoError(() => checkAndSetImportJobState(params)),
+        query: (params, showParams) => withMongoError(() => query(params, showParams)),
+        createProjection,
+        queryById: (params) => withMongoError(() => queryById(params)),
+        checkTimeOut: (params) => withMongoError(() => checkTimeOut(params)),
+        remove,
+        readContent: (correlationId) => withMongoError(() => readContent(correlationId)),
+        removeContent: (params) => withMongoError(() => removeContent(params)),
+        getOne,
+        getStream,
+        setState: (params) => withMongoError(() => setState(params)),
+        setImportJobState: (params) => withMongoError(() => setImportJobState(params)),
+        pushIds,
+        pushMessages,
+        setOperation: (params) => withMongoError(() => setOperation(params)),
+        setOperations: (params) => withMongoError(() => setOperations(params)),
+        addBlobSize: (params) => withMongoError(() => addBlobSize(params)),
+        setBlobSize: (params) => withMongoError(() => setBlobSize(params))
     };
-    if (stream) {
-      debug(`Creating streamBulk`);
-      try {
-        await new Promise((resolve, reject) => {
-          const outputStream = gridFSBucket.openUploadStream(correlationId);
-          stream.on("error", reject).on("data", (chunk) => outputStream.write(chunk)).on("end", () => outputStream.end(void 0, void 0, () => {
-            resolve(correlationId);
-          }));
-        });
-        logger.info(`New BULK queue item for ${operation} ${correlationId} has been made in ${collection}!`);
-        debug(`New BULK queue item for ${operation} ${correlationId} has been made in ${collection}!`);
-        return operator.insertOne(newQueueItem);
-      } catch (error) {
-        const errorMessage = error.payload || error.message || "";
-        logError(error);
-        throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
-      }
-    }
-    logger.debug(`No stream`);
-    debug(`Creating noStreamBulk`);
-    if (!stream) {
-      try {
-        const result = await operator.insertOne(newQueueItem);
-        if (result.acknowledged) {
-          logger.info(`New noStream BULK queue item for ${operation} ${correlationId} has been made in ${collection}`);
-          debug(`New noStream BULK queue item for ${operation} ${correlationId} has been made in ${collection}`);
-          return { correlationId, queueItemState: QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS };
-        }
-        throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR);
-      } catch (error) {
-        const errorMessage = error.payload || error.message || "";
-        logError(error);
-        throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
-      }
+    async function createPrio({ correlationId, cataloger, oCatalogerIn, operation, operationSettings }) {
+        debugDev('createPrio');
+        const time = new Date();
+        const newQueueItem = {
+            correlationId,
+            cataloger,
+            operation,
+            operations: [operation],
+            oCatalogerIn,
+            operationSettings: {
+                prio: true,
+                ...operationSettings
+            },
+            queueItemState: QUEUE_ITEM_STATE.VALIDATOR.PENDING_VALIDATION,
+            blobSize: 1,
+            importJobState: {
+                CREATE: IMPORT_JOB_STATE.EMPTY,
+                UPDATE: IMPORT_JOB_STATE.EMPTY,
+                FIX: IMPORT_JOB_STATE.EMPTY
+            },
+            records: [],
+            errorMessage: '',
+            errorStatus: '',
+            creationTime: time,
+            modificationTime: time
+        };
+        try {
+            debugDev(`Inserting: ${JSON.stringify(newQueueItem)} to ${collection}}`);
+            const result = await operator.insertOne(newQueueItem);
+            debugDev(JSON.stringify(result));
+            if (result.acknowledged) {
+                logger.info(`New PRIO queue item for ${operation} ${correlationId} has been made in ${collection}`);
+                return;
+            }
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, undefined);
+        }
+        catch (error) {
+            const apiError = error;
+            const errorMessage = apiError.payload || apiError.message || '';
+            logError(error);
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+        }
     }
-  }
-  async function checkAndSetState({ correlationId, state, errorMessage = void 0, errorStatus = void 0 }) {
-    const timeOut = await checkTimeOut({ correlationId });
-    if (timeOut) {
-      return setState({ correlationId, state, errorMessage, errorStatus });
+    async function createBulk({ correlationId, cataloger, oCatalogerIn, operation, contentType, recordLoadParams, stream, operationSettings }) {
+        const time = new Date();
+        const newQueueItem = {
+            correlationId,
+            cataloger,
+            oCatalogerIn,
+            operation,
+            operations: [operation],
+            operationSettings: {
+                prio: false,
+                ...operationSettings
+            },
+            contentType,
+            recordLoadParams,
+            queueItemState: stream ? QUEUE_ITEM_STATE.VALIDATOR.UPLOADING : QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS,
+            blobSize: 0,
+            importJobState: {
+                CREATE: IMPORT_JOB_STATE.EMPTY,
+                UPDATE: IMPORT_JOB_STATE.EMPTY,
+                FIX: IMPORT_JOB_STATE.EMPTY
+            },
+            records: [],
+            errorMessage: '',
+            errorStatus: '',
+            creationTime: time,
+            modificationTime: time
+        };
+        if (stream) {
+            debug(`Creating streamBulk`);
+            try {
+                await new Promise((resolve, reject) => {
+                    const outputStream = gridFSBucket.openUploadStream(correlationId);
+                    outputStream.on('error', (error) => {
+                        outputStream.destroy();
+                        reject(error);
+                    });
+                    stream
+                        .on('error', (error) => {
+                        outputStream.destroy();
+                        reject(error);
+                    })
+                        .on('data', chunk => outputStream.write(chunk))
+                        .on('end', () => outputStream.end(undefined, () => {
+                        resolve(correlationId);
+                    }));
+                });
+                logger.info(`New BULK queue item for ${operation} ${correlationId} has been made in ${collection}!`);
+                debug(`New BULK queue item for ${operation} ${correlationId} has been made in ${collection}!`);
+                const result = await operator.insertOne(newQueueItem);
+                if (!result.acknowledged) {
+                    throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, undefined);
+                }
+                return { correlationId, acknowledged: result.acknowledged, queueItemState: newQueueItem.queueItemState };
+            }
+            catch (error) {
+                const apiError = error;
+                const errorMessage = apiError.payload || apiError.message || '';
+                logError(error);
+                await removePartialContent(correlationId);
+                throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+            }
+        }
+        async function removePartialContent(correlationId) {
+            try {
+                const files = await gridFSBucket.find({ filename: correlationId }).toArray();
+                for (const file of files) {
+                    await gridFSBucket.delete(file._id);
+                    logger.debug(`mongo/createBulk: removed partial GridFS file for ${correlationId}`);
+                }
+            }
+            catch (cleanupError) {
+                const apiError = cleanupError;
+                logger.debug(`mongo/createBulk: partial GridFS cleanup failed for ${correlationId}: ${apiError.message}`);
+            }
+        }
+        logger.debug(`No stream`);
+        debug(`Creating noStreamBulk`);
+        if (!stream) {
+            try {
+                const result = await operator.insertOne(newQueueItem);
+                if (result.acknowledged) {
+                    logger.info(`New noStream BULK queue item for ${operation} ${correlationId} has been made in ${collection}`);
+                    debug(`New noStream BULK queue item for ${operation} ${correlationId} has been made in ${collection}`);
+                    return { correlationId, acknowledged: result.acknowledged, queueItemState: QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS };
+                }
+                throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, undefined);
+            }
+            catch (error) {
+                const apiError = error;
+                const errorMessage = apiError.payload || apiError.message || '';
+                logError(error);
+                throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+            }
+        }
+        return undefined;
     }
-    return false;
-  }
-  async function checkAndSetImportJobState({ correlationId, operation, importJobState }) {
-    logger.debug(`${correlationId}, ${importJobState}, ${operation}`);
-    const timeOut = await checkTimeOut({ correlationId, operation, importJobState });
-    if (timeOut) {
-      return setImportJobState({ correlationId, operation, importJobState });
+    async function checkAndSetState({ correlationId, state, errorMessage = undefined, errorStatus = undefined }) {
+        assertString(correlationId, 'correlationId');
+        const timeOut = await checkTimeOut({ correlationId });
+        if (timeOut) {
+            const queueItem = await setState({ correlationId, state, errorMessage, errorStatus });
+            return { status: 'updated', queueItem };
+        }
+        const queueItem = await operator.findOne({ correlationId }, { projection: { _id: 0 } });
+        const status = queueItem && queueItem.queueItemState === QUEUE_ITEM_STATE.ABORT ? 'timeout' : 'unchanged';
+        return { status, queueItem };
     }
-    return false;
-  }
-  async function query(params, showParams = {}) {
-    logger.debug(`Querying: ${JSON.stringify(params)}, ${JSON.stringify(showParams)}`);
-    debug(`Querying: ${JSON.stringify(params)}, ${JSON.stringify(showParams)}`);
-    const { limit = 1e3, skip = 0, ...rest } = params;
-    const result = await operator.find(rest, { projection: createProjection(showParams) }).limit(parseInt(limit, 10)).skip(parseInt(skip, 10)).toArray();
-    logger.debug(`Query result: ${result.length > 0 ? "Found!" : "Not found!"}`);
-    logger.silly(`${JSON.stringify(result)}`);
-    debug(`${JSON.stringify(result)}`);
-    return result;
-  }
-  function createProjection(showParams = {}) {
-    logger.silly(`Creating projection for query: ${JSON.stringify(showParams)}`);
-    debug(`Creating projection for query: ${JSON.stringify(showParams)}`);
-    const { showAll = 0, showOperations = 0, showOperationSettings = 0, showRecordLoadParams = 0, showImportJobState = 0 } = showParams;
-    const combinedShowParams = {
-      showAll,
-      showOperations,
-      showOperationSettings,
-      showRecordLoadParams,
-      showImportJobState
-    };
-    logger.debug(`showAll: ${showAll}, showOperations: ${showOperations}, showOperationSettings: ${showOperationSettings}, showRecordLoadParams: ${showRecordLoadParams}, showImportJobState: ${showImportJobState}`);
-    debug(`showAll: ${showAll}, showOperations: ${showOperations}, showOperationSettings: ${showOperationSettings}, showRecordLoadParams: ${showRecordLoadParams}, showImportJobState: ${showImportJobState}`);
-    debug(`${JSON.stringify(combinedShowParams)}`);
-    if (parseBoolean(showAll)) {
-      debug(`ShowAll: ${showAll}`);
-      return {
-        _id: 0
-      };
+    async function checkAndSetImportJobState({ correlationId, operation, importJobState }) {
+        assertString(correlationId, 'correlationId');
+        logger.debug(`${correlationId}, ${importJobState}, ${operation}`);
+        const timeOut = await checkTimeOut({ correlationId, operation, importJobState });
+        if (timeOut) {
+            const queueItem = await setImportJobState({ correlationId, operation, importJobState });
+            return { status: 'updated', queueItem };
+        }
+        const queueItem = await operator.findOne({ correlationId }, { projection: { _id: 0 } });
+        const status = queueItem && queueItem.queueItemState === QUEUE_ITEM_STATE.ABORT ? 'timeout' : 'unchanged';
+        return { status, queueItem };
     }
-    const showParamToField = {
-      "showOperations": "operations",
-      "showOperationSettings": "operationSettings",
-      "showRecordLoadParams": "recordLoadParams",
-      "showImportJobState": "importJobState"
-    };
-    const result = Object.keys(combinedShowParams).filter((param) => param !== "showAll" && !parseBoolean(combinedShowParams[param])).filter((param) => showParamToField[param]).map((param) => showParamToField[param]);
-    logger.silly(`We want to exclude from projection: ${JSON.stringify(result)}`);
-    debug(`We want to exclude from projection: ${JSON.stringify(result)}`);
-    const excludeObject = Object.fromEntries(result.map((param) => [param, 0]));
-    logger.silly(`We want to exclude from projection: ${JSON.stringify(excludeObject)}`);
-    debug(`We want to exclude from projection: ${JSON.stringify(excludeObject)}`);
-    return {
-      _id: 0,
-      ...excludeObject
-    };
-  }
-  async function queryById({ correlationId, checkModTime = false }) {
-    if (checkModTime) {
-      debug(`queryById checkModTime: ${checkModTime}`);
-      await checkTimeOut({ correlationId });
-      return queryById({ correlationId });
+    async function query(params, showParams = {}) {
+        logger.debug(`Querying: ${JSON.stringify(params)}, ${JSON.stringify(showParams)}`);
+        debug(`Querying: ${JSON.stringify(params)}, ${JSON.stringify(showParams)}`);
+        const { limit = 1000, skip = 0, ...rest } = params;
+        const result = await operator.find(rest, { projection: createProjection(showParams) })
+            .limit(parseInt(String(limit), 10))
+            .skip(parseInt(String(skip), 10))
+            .toArray();
+        logger.debug(`Query result: ${result.length > 0 ? 'Found!' : 'Not found!'}`);
+        logger.silly(`${JSON.stringify(result)}`);
+        debug(`${JSON.stringify(result)}`);
+        return result;
     }
-    const result = await operator.findOne({ correlationId }, { projection: { _id: 0 } });
-    return result;
-  }
-  async function checkTimeOut({ correlationId }) {
-    const { modificationTime, queueItemState: oldState, importJobState } = await operator.findOne({ correlationId });
-    if ([QUEUE_ITEM_STATE.ABORT, QUEUE_ITEM_STATE.ERROR, QUEUE_ITEM_STATE.DONE].includes(oldState)) {
-      logger.silly(`${correlationId} has already state: ${oldState}`);
-      return false;
+    function createProjection(showParams = {}) {
+        logger.silly(`Creating projection for query: ${JSON.stringify(showParams)}`);
+        debug(`Creating projection for query: ${JSON.stringify(showParams)}`);
+        const { showAll = 0, showOperations = 0, showOperationSettings = 0, showRecordLoadParams = 0, showImportJobState = 0 } = showParams;
+        const combinedShowParams = {
+            showAll,
+            showOperations,
+            showOperationSettings,
+            showRecordLoadParams,
+            showImportJobState
+        };
+        logger.debug(`showAll: ${showAll}, showOperations: ${showOperations}, showOperationSettings: ${showOperationSettings}, showRecordLoadParams: ${showRecordLoadParams}, showImportJobState: ${showImportJobState}`);
+        debug(`showAll: ${showAll}, showOperations: ${showOperations}, showOperationSettings: ${showOperationSettings}, showRecordLoadParams: ${showRecordLoadParams}, showImportJobState: ${showImportJobState}`);
+        debug(`${JSON.stringify(combinedShowParams)}`);
+        if (parseBoolean(showAll)) {
+            debug(`ShowAll: ${showAll}`);
+            return {
+                _id: 0
+            };
+        }
+        const showParamToField = {
+            'showOperations': 'operations',
+            'showOperationSettings': 'operationSettings',
+            'showRecordLoadParams': 'recordLoadParams',
+            'showImportJobState': 'importJobState'
+        };
+        const result = Object.keys(combinedShowParams)
+            .filter(param => param !== 'showAll' && !parseBoolean(combinedShowParams[param]))
+            .filter((param) => param in showParamToField)
+            .map(param => showParamToField[param]);
+        logger.silly(`We want to exclude from projection: ${JSON.stringify(result)}`);
+        debug(`We want to exclude from projection: ${JSON.stringify(result)}`);
+        const excludeObject = Object.fromEntries(result.map(param => [param, 0]));
+        logger.silly(`We want to exclude from projection: ${JSON.stringify(excludeObject)}`);
+        debug(`We want to exclude from projection: ${JSON.stringify(excludeObject)}`);
+        return {
+            _id: 0,
+            ...excludeObject
+        };
     }
-    const timeoutTime = moment(modificationTime).add(1, "m");
-    logger.silly(`${correlationId} timeOut @ ${timeoutTime}`);
-    if (timeoutTime.isBefore()) {
-      const finalImportJobStates = [IMPORT_JOB_STATE.ABORT, IMPORT_JOB_STATE.DONE, IMPORT_JOB_STATE.EMPTY, IMPORT_JOB_STATE.ERROR];
-      if (!finalImportJobStates.includes(importJobState.CREATE)) {
-        await setImportJobState({ correlationId, operation: "CREATE", importJobState: IMPORT_JOB_STATE.ABORT });
-      }
-      if (!finalImportJobStates.includes(importJobState.UPDATE)) {
-        await setImportJobState({ correlationId, operation: "UPDATE", importJobState: IMPORT_JOB_STATE.ABORT });
-      }
-      if (!finalImportJobStates.includes(importJobState.FIX)) {
-        await setImportJobState({ correlationId, operation: "FIX", importJobState: IMPORT_JOB_STATE.ABORT });
-      }
-      await setState({ correlationId, state: QUEUE_ITEM_STATE.ABORT, errorStatus: httpStatus.REQUEST_TIMEOUT, errorMessage: `Timeout in ${oldState}` });
-      return false;
+    async function queryById({ correlationId, checkModTime = false }) {
+        assertString(correlationId, 'correlationId');
+        if (checkModTime) {
+            debug(`queryById checkModTime: ${checkModTime}`);
+            await checkTimeOut({ correlationId });
+            return queryById({ correlationId });
+        }
+        const result = await operator.findOne({ correlationId }, { projection: { _id: 0 } });
+        return result;
     }
-    return true;
-  }
-  async function remove(params) {
-    logger.silly(`${JSON.stringify(params)}`);
-    logger.info(`Removing from Mongo (${collection}) id: ${params.correlationId}`);
-    debug(`${JSON.stringify(params)}`);
-    debug(`Removing from Mongo (${collection}) id: ${params.correlationId}`);
-    const clean = sanitize(params.correlationId);
-    logger.silly(`mongo/remove: clean: ${JSON.stringify(clean)}`);
-    debug(`mongo/remove: clean: ${JSON.stringify(clean)}`);
-    try {
-      const noContent = await removeContent({ correlationId: params.correlationId });
-      debug(`noContent (removeContent result): ${JSON.stringify(noContent)}`);
-      if (noContent) {
-        const deleteResult = await operator.deleteOne({ correlationId: clean });
-        debug(`deleteResult: ${JSON.stringify(deleteResult)}`);
+    async function checkTimeOut({ correlationId }) {
+        assertString(correlationId, 'correlationId');
+        const queueItem = await operator.findOne({ correlationId });
+        if (!queueItem) {
+            logger.silly(`${correlationId} not found in ${collection} - not a timeout`);
+            return false;
+        }
+        const { modificationTime, queueItemState: oldState, importJobState = { CREATE: IMPORT_JOB_STATE.EMPTY, UPDATE: IMPORT_JOB_STATE.EMPTY, FIX: IMPORT_JOB_STATE.EMPTY } } = queueItem;
+        if (oldState === QUEUE_ITEM_STATE.ABORT || oldState === QUEUE_ITEM_STATE.ERROR || oldState === QUEUE_ITEM_STATE.DONE) {
+            logger.silly(`${correlationId} has already state: ${oldState}`);
+            return false;
+        }
+        const timeoutTime = new Date(new Date(modificationTime).getTime() + timeoutMinutes * 60000);
+        logger.silly(`${correlationId} timeOut @ ${timeoutTime}`);
+        if (timeoutTime < new Date()) {
+            const finalImportJobStates = [IMPORT_JOB_STATE.ABORT, IMPORT_JOB_STATE.DONE, IMPORT_JOB_STATE.EMPTY, IMPORT_JOB_STATE.ERROR];
+            if (!finalImportJobStates.includes(importJobState.CREATE)) {
+                await setImportJobState({ correlationId, operation: 'CREATE', importJobState: IMPORT_JOB_STATE.ABORT });
+            }
+            if (!finalImportJobStates.includes(importJobState.UPDATE)) {
+                await setImportJobState({ correlationId, operation: 'UPDATE', importJobState: IMPORT_JOB_STATE.ABORT });
+            }
+            if (!finalImportJobStates.includes(importJobState.FIX)) {
+                await setImportJobState({ correlationId, operation: 'FIX', importJobState: IMPORT_JOB_STATE.ABORT });
+            }
+            await setState({ correlationId, state: QUEUE_ITEM_STATE.ABORT, errorStatus: httpStatus.REQUEST_TIMEOUT, errorMessage: `Timeout in ${oldState}` });
+            return false;
+        }
         return true;
-      }
-    } catch (err) {
-      if (err instanceof MongoDriverError) {
-        debug(err);
-        if (err.message.indexOf("File not found for id") !== -1) {
-          logger.silly(`mongo/remove: File not found, removing queueItem ${JSON.stringify(clean)} from ${collection}`);
-          debug(`mongo/remove: File not found, removing queueItem ${JSON.stringify(clean)} from ${collection}`);
-          await operator.deleteOne({ correlationId: clean });
-          return true;
-        }
-        logger.error(err.message);
-        throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, err.message);
-      }
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, err.message);
     }
-  }
-  async function readContent(correlationId) {
-    logger.info(`Reading content from mongo for id: ${correlationId} in ${collection}`);
-    debug(`Reading content from mongo for id: ${correlationId} in ${collection}`);
-    const clean = sanitize(correlationId);
-    debug(clean);
-    const result = await operator.findOne({ correlationId: clean });
-    debug(result);
-    if (result) {
-      const { operationSettings } = result;
-      if (operationSettings.prio === false && operationSettings.noStream === false) {
-        return {
-          contentType: result.contentType,
-          readStream: gridFSBucket.openDownloadStreamByName(clean)
+    async function remove(params) {
+        logger.silly(`${JSON.stringify(params)}`);
+        logger.info(`Removing from Mongo (${collection}) id: ${params.correlationId}`);
+        debug(`${JSON.stringify(params)}`);
+        debug(`Removing from Mongo (${collection}) id: ${params.correlationId}`);
+        assertString(params.correlationId, 'correlationId');
+        try {
+            const removedContent = await removeContent({ correlationId: params.correlationId });
+            debug(`removedContent (removeContent result): ${JSON.stringify(removedContent)}`);
+            const deleteResult = await operator.deleteOne({ correlationId: params.correlationId });
+            debug(`deleteResult: ${JSON.stringify(deleteResult)}`);
+            return { removed: deleteResult.deletedCount > 0, deletedContent: removedContent };
+        }
+        catch (err) {
+            if (err instanceof MongoDriverError) {
+                debug(err);
+                if (err.message.indexOf('File not found for id') !== -1) {
+                    logger.silly(`mongo/remove: File not found, removing queueItem ${JSON.stringify(params.correlationId)} from ${collection}`);
+                    debug(`mongo/remove: File not found, removing queueItem ${JSON.stringify(params.correlationId)} from ${collection}`);
+                    const deleteResult = await operator.deleteOne({ correlationId: params.correlationId });
+                    return { removed: deleteResult.deletedCount > 0, deletedContent: false };
+                }
+                logger.error(err.message);
+                throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, err.message);
+            }
+            const driverError = err;
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, driverError.message);
+        }
+    }
+    async function readContent(correlationId) {
+        logger.info(`Reading content from mongo for id: ${correlationId} in ${collection}`);
+        debug(`Reading content from mongo for id: ${correlationId} in ${collection}`);
+        assertString(correlationId, 'correlationId');
+        const result = await operator.findOne({ correlationId });
+        debug(result);
+        if (result) {
+            const { operationSettings } = result;
+            let files = [];
+            if (operationSettings.prio === false) {
+                files = await gridFSBucket.find({ filename: correlationId }).toArray();
+            }
+            const hasContent = files.length > 0;
+            if (hasContent) {
+                return {
+                    contentType: result.contentType,
+                    readStream: gridFSBucket.openDownloadStreamByName(correlationId)
+                };
+            }
+            logger.debug(`OperationSettings for ${correlationId}: ${JSON.stringify(operationSettings)}`);
+            debug(`OperationSettings for ${correlationId}: ${JSON.stringify(operationSettings)}`);
+            debug(`Content is only available for streamBulk jobs. ${correlationId} is not a streamBulk job.`);
+            throw new ApiError(httpStatus.BAD_REQUEST, { message: `Content is only available for streamBulk jobs. ${correlationId} is not a streamBulk job.` });
+        }
+        throw new ApiError(httpStatus.NOT_FOUND, { message: `Job ${correlationId} not found.` });
+    }
+    async function removeContent(params) {
+        logger.info(`Removing content from mongo for id: ${params.correlationId} in ${collection}`);
+        debug(`Removing content from mongo for id: ${params.correlationId} in ${collection}`);
+        assertString(params.correlationId, 'correlationId');
+        const result = await gridFSBucket.find({ filename: params.correlationId }).toArray();
+        debug(`mongo/removeContent: find bucket result ${JSON.stringify(result)}`);
+        if (result.length > 0) {
+            const [firstBucketResult] = result;
+            const fileId = firstBucketResult._id;
+            await gridFSBucket.delete(fileId);
+            return true;
+        }
+        logger.debug(`No files for ${params.correlationId} to delete`);
+        return false;
+    }
+    async function getOne({ queueItemState, importJobState = undefined }) {
+        logger.silly(`queueItemState: ${queueItemState}, importJobState: ${JSON.stringify(importJobState)}`);
+        if (queueItemState) {
+            assertString(queueItemState, 'queueItemState');
+        }
+        if (importJobState) {
+            assertImportJobStateFilter(importJobState, 'importJobState');
+        }
+        const cleanQueueItemState = queueItemState ? { queueItemState } : undefined;
+        const options = { projection: { _id: 0 } };
+        try {
+            if (queueItemState && importJobState === undefined) {
+                logger.silly(`Checking DB ${collection} for just ${JSON.stringify(queueItemState)}`);
+                return operator.findOne({ queueItemState }, options);
+            }
+            if (importJobState && queueItemState === undefined) {
+                logger.silly(`Checking DB ${collection} for ${JSON.stringify(importJobState)}`);
+                return operator.findOne({ ...importJobState }, options);
+            }
+            if (importJobState && queueItemState) {
+                logger.silly(`Checking DB ${collection} for ${queueItemState} and ${JSON.stringify(importJobState)}`);
+                return operator.findOne({ ...cleanQueueItemState, ...importJobState }, options);
+            }
+            logger.debug(`getOne not working!`);
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, 'Missing parameters, cannot get queueItem');
+        }
+        catch (error) {
+            const apiError = error;
+            const errorMessage = apiError.payload || apiError.message || '';
+            logError(error);
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+        }
+    }
+    async function getStream(correlationId) {
+        logger.info(`Forming stream from mongo for ${correlationId} in ${collection}`);
+        assertString(correlationId, 'correlationId');
+        try {
+            const files = await gridFSBucket.find({ filename: correlationId }).toArray();
+            if (files.length === 0) {
+                logger.info(`getStream: file ${correlationId} not found in ${collection}`);
+                throw new ApiError(httpStatus.NOT_FOUND, { message: `File ${correlationId} not found in ${collection}` });
+            }
+            return gridFSBucket.openDownloadStreamByName(correlationId);
+        }
+        catch (error) {
+            if (error instanceof ApiError) {
+                throw error;
+            }
+            const apiError = error;
+            const errorMessage = apiError.payload || apiError.message || '';
+            logError(error);
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+        }
+    }
+    async function pushIds({ correlationId, handledIds, rejectedIds }) {
+        if (!Array.isArray(handledIds) || !Array.isArray(rejectedIds)) {
+            throw new ApiError(httpStatus.BAD_REQUEST, 'pushIds: handledIds and rejectedIds must be arrays');
+        }
+        assertString(correlationId, 'correlationId');
+        logger.verbose(`Push ids (${handledIds.length}) and rejectedIds (${rejectedIds.length}) ${correlationId} to ${collection}`);
+        logger.debug(`ids (${handledIds.length}): ${JSON.stringify(handledIds)}, rejectedIds ${rejectedIds.length}: ${JSON.stringify(rejectedIds)}`);
+        try {
+            await operator.updateOne({
+                correlationId
+            }, {
+                $set: {
+                    modificationTime: new Date()
+                },
+                $push: {
+                    handledIds: { $each: handledIds },
+                    rejectedIds: { $each: rejectedIds }
+                }
+            });
+        }
+        catch (error) {
+            const apiError = error;
+            const errorMessage = apiError.payload || apiError.message || '';
+            logError(error);
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+        }
+    }
+    async function pushMessages({ correlationId, messages, messageField = 'messages' }) {
+        if (!Array.isArray(messages)) {
+            throw new ApiError(httpStatus.BAD_REQUEST, 'pushMessages: messages must be an array');
+        }
+        assertString(correlationId, 'correlationId');
+        assertString(messageField, 'messageField');
+        logger.verbose(`Push messages (${messages.length}) to ${messageField} ${correlationId} to ${collection}`);
+        logger.silly(`Messages (${messages.length}): ${JSON.stringify(messages)}`);
+        try {
+            await operator.updateOne({
+                correlationId
+            }, {
+                $set: {
+                    modificationTime: new Date()
+                },
+                $push: {
+                    [messageField]: { $each: messages }
+                }
+            });
+        }
+        catch (error) {
+            const apiError = error;
+            const errorMessage = apiError.payload || apiError.message || '';
+            logError(error);
+            throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+        }
+    }
+    function setState({ correlationId, state, errorMessage = undefined, errorStatus = undefined }) {
+        assertString(correlationId, 'correlationId');
+        const errorString = errorMessage || errorStatus ? `, Error message: '${JSON.stringify(errorMessage) || ''}', Error status: '${errorStatus || ''}'` : '';
+        logger.info(`Setting queue-item state ${state} for ${correlationId}${errorString} to ${collection}`);
+        const allQueueItemStates = [
+            QUEUE_ITEM_STATE.DONE,
+            QUEUE_ITEM_STATE.ERROR,
+            QUEUE_ITEM_STATE.ABORT,
+            ...Object.values(QUEUE_ITEM_STATE.VALIDATOR),
+            ...Object.values(QUEUE_ITEM_STATE.IMPORTER)
+        ];
+        if (!allQueueItemStates.includes(state)) {
+            debug(`Trying to set invalid state ${state}`);
+            throw new ApiError(httpStatus.BAD_REQUEST, 'Trying to set invalid state');
+        }
+        const updateValues = {
+            queueItemState: state,
+            modificationTime: new Date(),
+            errorMessage,
+            errorStatus
         };
-      }
-      logger.debug(`OperationSettings for ${correlationId}: ${JSON.stringify(operationSettings)}`);
-      debug(`OperationSettings for ${correlationId}: ${JSON.stringify(operationSettings)}`);
-      debug(`Content is only available for streamBulk jobs. ${correlationId} is not a streamBulk job.`);
-      throw new ApiError(httpStatus.BAD_REQUEST, { message: `Content is only available for streamBulk jobs. ${correlationId} is not a streamBulk job.` });
+        Object.keys(updateValues).forEach(key => updateValues[key] === undefined && delete updateValues[key]);
+        return operator
+            .findOneAndUpdate({ correlationId }, { $set: updateValues }, { projection: { _id: 0 }, returnDocument: 'after' });
     }
-    throw new ApiError(httpStatus.NOT_FOUND, { message: `Job ${correlationId} not found.` });
-  }
-  async function removeContent(params) {
-    logger.info(`Removing content from mongo for id: ${params.correlationId} in ${collection}`);
-    debug(`Removing content from mongo for id: ${params.correlationId} in ${collection}`);
-    const clean = sanitize(params.correlationId);
-    const result = await gridFSBucket.find({ filename: clean }).toArray();
-    debug(`mongo/removeContent: find bucket result ${JSON.stringify(result)}`);
-    if (result.length > 0) {
-      const [firstBucketResult] = result;
-      const fileId = firstBucketResult._id;
-      await gridFSBucket.delete(fileId);
-      return true;
+    function setImportJobState({ correlationId, operation, importJobState }) {
+        assertString(correlationId, 'correlationId');
+        logger.info(`Setting queue-item importJobState: {${operation}: ${importJobState}} for ${correlationId}`);
+        debug(`Setting queue-item importJobState: {${operation}: ${importJobState}} for ${correlationId}`);
+        if (!(operation in OPERATIONS)) {
+            debug(`Error: ${operation} is not in ${JSON.stringify(OPERATIONS)}`);
+            throw new ApiError(httpStatus.BAD_REQUEST, 'Invalid operation for import job state');
+        }
+        if (!(importJobState in IMPORT_JOB_STATE)) {
+            debug(`Error: ${importJobState} is not in ${JSON.stringify(IMPORT_JOB_STATE)}`);
+            throw new ApiError(httpStatus.BAD_REQUEST, 'Invalid import job state');
+        }
+        const newJobState = getNewJobState(operation, importJobState);
+        return operator.findOneAndUpdate({
+            correlationId
+        }, {
+            $set: {
+                ...newJobState,
+                modificationTime: new Date()
+            }
+        }, { projection: { _id: 0 }, returnDocument: 'after' });
     }
-    logger.debug(`No files for ${params.correlationId} to delete`);
-    return true;
-  }
-  function getOne({ queueItemState, importJobState = void 0 }) {
-    logger.silly(`queueItemState: ${queueItemState}, importJobState: ${JSON.stringify(importJobState)}`);
-    const cleanQueueItemState = queueItemState ? { queueItemState: sanitize(queueItemState) } : void 0;
-    const options = { projection: { _id: 0 } };
-    try {
-      if (queueItemState && importJobState === void 0) {
-        logger.silly(`Checking DB ${collection} for just ${JSON.stringify(cleanQueueItemState.queueItemState)}`);
-        return operator.findOne({ ...cleanQueueItemState }, options);
-      }
-      if (importJobState && queueItemState === void 0) {
-        logger.silly(`Checking DB ${collection} for ${JSON.stringify(importJobState)}`);
-        return operator.findOne({ ...importJobState }, options);
-      }
-      if (importJobState && queueItemState) {
-        logger.silly(`Checking DB ${collection} for ${queueItemState} and ${JSON.stringify(importJobState)}`);
-        return operator.findOne({ ...cleanQueueItemState, ...importJobState }, options);
-      }
-      logger.debug(`getOne not working!`);
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, "Missing parameters, cannot get queueItem");
-    } catch (error) {
-      const errorMessage = error.payload || error.message || "";
-      logError(error);
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+    function getNewJobState(operation, importJobState) {
+        if (operation === OPERATIONS.CREATE) {
+            return { 'importJobState.CREATE': importJobState };
+        }
+        if (operation === OPERATIONS.UPDATE) {
+            return { 'importJobState.UPDATE': importJobState };
+        }
+        if (operation === OPERATIONS.FIX) {
+            return { 'importJobState.FIX': importJobState };
+        }
+        throw new ApiError(httpStatus.BAD_REQUEST, 'Invalid operation for import job state');
     }
-  }
-  function getStream(correlationId) {
-    logger.info(`Forming stream from mongo for ${correlationId} in ${collection}`);
-    const clean = sanitize(correlationId);
-    try {
-      return gridFSBucket.openDownloadStreamByName(clean);
-    } catch (error) {
-      const errorMessage = error.payload || error.message || "";
-      logError(error);
-      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+    function unwrapAndUpdateResult(result, correlationId) {
+        if (result === null || result === undefined) {
+            logger.info(`Queue item ${correlationId} not found in ${collection}`);
+            throw new ApiError(httpStatus.NOT_FOUND, { message: `Job ${correlationId} not found.` });
+        }
+        return result;
     }
-  }
-  async function pushIds({ correlationId, handledIds, rejectedIds }) {
-    logger.verbose(`Push ids (${handledIds.length}) and rejectedIds (${rejectedIds.length}) ${correlationId} to ${collection}`);
-    logger.debug(`ids (${handledIds.length}): ${JSON.stringify(handledIds)}, rejectedIds ${rejectedIds.length}: ${JSON.stringify(rejectedIds)}`);
-    const clean = sanitize(correlationId);
-    await operator.updateOne({
-      correlationId: clean
-    }, {
-      $set: {
-        modificationTime: moment().toDate()
-      },
-      $push: {
-        handledIds: { $each: handledIds },
-        rejectedIds: { $each: rejectedIds }
-      }
-    });
-  }
-  async function pushMessages({ correlationId, messages, messageField = "messages" }) {
-    logger.verbose(`Push messages (${messages.length}) to ${messageField} ${correlationId} to ${collection}`);
-    logger.silly(`Messages (${messages.length}): ${JSON.stringify(messages)}}`);
-    const clean = sanitize(correlationId);
-    const cleanMessageField = sanitize(messageField);
-    debug(`${messageField} -> ${cleanMessageField}`);
-    await operator.updateOne({
-      correlationId: clean
-    }, {
-      $set: {
-        modificationTime: moment().toDate()
-      },
-      $push: {
-        [cleanMessageField]: { $each: messages }
-      }
-    });
-  }
-  function setState({ correlationId, state, errorMessage = void 0, errorStatus = void 0 }) {
-    const errorString = errorMessage || errorStatus ? `, Error message: '${JSON.stringify(errorMessage) || ""}', Error status: '${errorStatus || ""}'` : "";
-    logger.info(`Setting queue-item state ${state} for ${correlationId}${errorString} to ${collection}`);
-    const stateInQueueItemStates = Object.values(QUEUE_ITEM_STATE).indexOf(state) > -1;
-    const stateInQueueItemStatesValidator = Object.values(QUEUE_ITEM_STATE.VALIDATOR).indexOf(state) > -1;
-    const stateInQueueItemStatesImporter = Object.values(QUEUE_ITEM_STATE.IMPORTER).indexOf(state) > -1;
-    if (!stateInQueueItemStates && !stateInQueueItemStatesValidator && !stateInQueueItemStatesImporter) {
-      debug(`Trying to set invalid state ${state}`);
-      throw new ApiError(httpStatus.BAD_REQUEST, "Trying to set invalid state");
+    async function setOperation({ correlationId, operation }) {
+        assertString(correlationId, 'correlationId');
+        const newOperation = operation;
+        const existing = await operator.findOne({ correlationId });
+        if (!existing) {
+            logger.info(`Setting queue-item operation: queue item ${correlationId} not found in ${collection}`);
+            throw new ApiError(httpStatus.NOT_FOUND, { message: `Job ${correlationId} not found.` });
+        }
+        const { operation: oldOperation } = existing;
+        logger.info(`Setting queue-item operation from ${oldOperation} to ${newOperation} for ${correlationId} to ${collection}`);
+        const result = await operator.findOneAndUpdate({
+            correlationId
+        }, {
+            $set: {
+                operation: newOperation,
+                modificationTime: new Date()
+            }
+        }, { projection: { _id: 0 }, returnDocument: 'after' });
+        debugDev(`${JSON.stringify(result)}`);
+        return unwrapAndUpdateResult(result, correlationId);
     }
-    const clean = sanitize(correlationId);
-    const updateValues = {
-      queueItemState: state,
-      modificationTime: moment().toDate(),
-      errorMessage,
-      errorStatus
-    };
-    Object.keys(updateValues).forEach((key) => updateValues[key] === void 0 && delete updateValues[key]);
-    return operator.findOneAndUpdate(
-      { correlationId: clean },
-      { $set: updateValues },
-      { projection: { _id: 0 }, returnDocument: "after" }
-    );
-  }
-  function setImportJobState({ correlationId, operation, importJobState }) {
-    logger.info(`Setting queue-item importJobState: {${operation}: ${importJobState}} for ${correlationId}`);
-    debug(`Setting queue-item importJobState: {${operation}: ${importJobState}} for ${correlationId}`);
-    const cleanCorrelationId = sanitize(correlationId);
-    const cleanImportJobState = sanitize(importJobState);
-    if (!(operation in OPERATIONS)) {
-      debug(`Error: ${operation} is not in ${JSON.stringify(OPERATIONS)}`);
-      throw new ApiError(httpStatus.BAD_REQUEST, "Invalid operation for import job state");
+    async function setOperations({ correlationId, addOperation, removeOperation = undefined }) {
+        assertString(correlationId, 'correlationId');
+        const queueItem = await operator.findOne({ correlationId });
+        logger.silly(`We found a queueItem: ${JSON.stringify(queueItem)}`);
+        if (!queueItem) {
+            logger.info(`Setting queue-item operations: queue item ${correlationId} not found in ${collection}`);
+            throw new ApiError(httpStatus.NOT_FOUND, { message: `Job ${correlationId} not found.` });
+        }
+        const oldOperations = queueItem.operations;
+        logger.info(`Setting queue-item operations from ${JSON.stringify(oldOperations)} by adding ${addOperation} and removing ${removeOperation} for ${correlationId} to ${collection}`);
+        const operationsAfterRemove = oldOperations.filter(operation => operation !== removeOperation);
+        const operationsAfterRemoveAndAdd = operationsAfterRemove.includes(addOperation) ? operationsAfterRemove : [...operationsAfterRemove, addOperation];
+        logger.silly(`operationsAfterRemove: ${operationsAfterRemove}`);
+        logger.silly(`operationAfterRemoveAndAdd: ${operationsAfterRemoveAndAdd}`);
+        const result = await operator.findOneAndUpdate({
+            correlationId
+        }, {
+            $set: {
+                operations: operationsAfterRemoveAndAdd,
+                modificationTime: new Date()
+            }
+        }, { projection: { _id: 0 }, returnDocument: 'after' });
+        debugDev(`${JSON.stringify(result)}`);
+        return unwrapAndUpdateResult(result, correlationId);
     }
-    if (!(cleanImportJobState in IMPORT_JOB_STATE)) {
-      debug(`Error: ${cleanImportJobState} is not in ${JSON.stringify(IMPORT_JOB_STATE)}`);
-      throw new ApiError(httpStatus.BAD_REQUEST, "Invalid import job state");
+    async function addBlobSize({ correlationId }) {
+        assertString(correlationId, 'correlationId');
+        const result = await operator.findOneAndUpdate({
+            correlationId,
+            queueItemState: QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS
+        }, {
+            $inc: {
+                blobSize: 1
+            },
+            $set: {
+                modificationTime: new Date()
+            }
+        }, { projection: { _id: 0 }, returnDocument: 'after' });
+        logger.verbose(`AddBlobSizeResult in mongo: ${JSON.stringify(result)}`);
+        debugDev(`${JSON.stringify(result)}`);
+        return result;
     }
-    const newJobState = getNewJobState(operation, cleanImportJobState);
-    function getNewJobState(operation2, cleanImportJobState2) {
-      if (operation2 === OPERATIONS.CREATE) {
-        return { "importJobState.CREATE": cleanImportJobState2 };
-      }
-      if (operation2 === OPERATIONS.UPDATE) {
-        return { "importJobState.UPDATE": cleanImportJobState2 };
-      }
-      if (operation2 === OPERATIONS.FIX) {
-        return { "importJobState.FIX": cleanImportJobState2 };
-      }
-      throw new ApiError("400", "Invalid operation for import job state");
+    async function setBlobSize({ correlationId, blobSize }) {
+        assertString(correlationId, 'correlationId');
+        assertNumber(blobSize, 'blobSize');
+        const result = await operator.findOneAndUpdate({
+            correlationId
+        }, {
+            $set: {
+                blobSize,
+                modificationTime: new Date()
+            }
+        }, { projection: { _id: 0 }, returnDocument: 'after' });
+        logger.verbose(`SetBlobSizeResult in mongo: ${JSON.stringify(result)}`);
+        debugDev(`${JSON.stringify(result)}`);
+        return result;
     }
-    return operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
-    }, {
-      $set: {
-        ...newJobState,
-        modificationTime: moment().toDate()
-      }
-    }, { projection: { _id: 0 }, returnDocument: "after" });
-  }
-  async function setOperation({ correlationId, operation }) {
-    const newOperation = operation;
-    const { operation: oldOperation } = await operator.findOne({ correlationId });
-    logger.info(`Setting queue-item operation from ${oldOperation} to ${newOperation} for ${correlationId} to ${collection}`);
-    const cleanCorrelationId = sanitize(correlationId);
-    const cleanNewOperation = sanitize(newOperation);
-    const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
-    }, {
-      $set: {
-        operation: cleanNewOperation,
-        modificationTime: moment().toDate()
-      }
-    }, { projection: { _id: 0 }, returnDocument: "after" });
-    debugDev(`${JSON.stringify(result)}`);
-    return result.ok || result;
-  }
-  async function setOperations({ correlationId, addOperation, removeOperation = void 0 }) {
-    const cleanCorrelationId = sanitize(correlationId);
-    const queueItem = await operator.findOne({ correlationId: cleanCorrelationId });
-    logger.silly(`We found a queueItem: ${JSON.stringify(queueItem)}`);
-    const oldOperations = queueItem.operations;
-    logger.info(`Setting queue-item operations from ${JSON.stringify(oldOperations)} by adding ${addOperation} and removing ${removeOperation} for ${correlationId} to ${collection}`);
-    const operationsAfterRemove = oldOperations.filter((operation) => operation !== removeOperation);
-    const operationsAfterRemoveAndAdd = operationsAfterRemove.includes(addOperation) ? operationsAfterRemove : [...operationsAfterRemove, addOperation];
-    logger.silly(`operationsAfterRemove: ${operationsAfterRemove}`);
-    logger.silly(`operationAfterRemoveAndAdd: ${operationsAfterRemoveAndAdd}`);
-    const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
-    }, {
-      $set: {
-        operations: operationsAfterRemoveAndAdd,
-        modificationTime: moment().toDate()
-      }
-    }, { projection: { _id: 0 }, returnDocument: "after" });
-    debugDev(`${JSON.stringify(result)}`);
-    return result.ok || result;
-  }
-  async function addBlobSize({ correlationId }) {
-    const cleanCorrelationId = sanitize(correlationId);
-    const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId,
-      queueItemState: QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS
-    }, {
-      $inc: {
-        blobSize: 1
-      },
-      $set: {
-        modificationTime: moment().toDate()
-      }
-    }, { projection: { _id: 0 }, returnDocument: "after" });
-    logger.verbose(`AddBlobSizeResult in mongo: ${JSON.stringify(result)}`);
-    debugDev(`${JSON.stringify(result)}`);
-    return result;
-  }
-  async function setBlobSize({ correlationId, blobSize }) {
-    const cleanCorrelationId = sanitize(correlationId);
-    const cleanBlobSize = sanitize(blobSize);
-    const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
-    }, {
-      $set: {
-        blobSize: cleanBlobSize,
-        modificationTime: moment().toDate()
-      }
-    }, { projection: { _id: 0 }, returnDocument: "after" });
-    logger.verbose(`SetBlobSizeResult in mongo: ${JSON.stringify(result)}`);
-    debugDev(`${JSON.stringify(result)}`);
-    return result;
-  }
 }
-//# sourceMappingURL=mongo.js.map
+//# sourceMappingURL=mongo.js.map