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

package/dist/mongo.js

@@ -1,25 +1,29 @@
 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 { 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") {
+import { logError, assertString, assertNumber, assertImportJobStateFilter } from "./utils.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 client = await MongoClient.connect(MONGO_URI);
-  const dbConnection = client.db(db);
-  const gridFSBucket = new GridFSBucket(dbConnection, { bucketName: collection });
-  const operator = dbConnection.collection(collection);
+  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);
+  }
   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 time = /* @__PURE__ */ new Date();
     const newQueueItem = {
       correlationId,
       cataloger,
@@ -59,7 +63,7 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     }
   }
   async function createBulk({ correlationId, cataloger, oCatalogerIn, operation, contentType, recordLoadParams, stream, operationSettings }) {
-    const time = moment().toDate();
+    const time = /* @__PURE__ */ new Date();
     const newQueueItem = {
       correlationId,
       cataloger,
@@ -90,19 +94,42 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
       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, () => {
+          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(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);
+        const result = await operator.insertOne(newQueueItem);
+        if (!result.acknowledged) {
+          throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR);
+        }
+        return { correlationId, acknowledged: result.acknowledged, queueItemState: newQueueItem.queueItemState };
       } catch (error) {
         const errorMessage = error.payload || error.message || "";
         logError(error);
+        await removePartialContent(correlationId);
         throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
       }
     }
+    async function removePartialContent(correlationId2) {
+      try {
+        const files = await gridFSBucket.find({ filename: correlationId2 }).toArray();
+        for (const file of files) {
+          await gridFSBucket.delete(file._id);
+          logger.debug(`mongo/createBulk: removed partial GridFS file for ${correlationId2}`);
+        }
+      } catch (cleanupError) {
+        logger.debug(`mongo/createBulk: partial GridFS cleanup failed for ${correlationId2}: ${cleanupError.message}`);
+      }
+    }
     logger.debug(`No stream`);
     debug(`Creating noStreamBulk`);
     if (!stream) {
@@ -111,7 +138,7 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
         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 };
+          return { correlationId, acknowledged: result.acknowledged, queueItemState: QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS };
         }
         throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR);
       } catch (error) {
@@ -122,19 +149,27 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     }
   }
   async function checkAndSetState({ correlationId, state, errorMessage = void 0, errorStatus = void 0 }) {
+    assertString(correlationId, "correlationId");
     const timeOut = await checkTimeOut({ correlationId });
     if (timeOut) {
-      return setState({ correlationId, state, errorMessage, errorStatus });
+      const queueItem2 = await setState({ correlationId, state, errorMessage, errorStatus });
+      return { status: "updated", queueItem: queueItem2 };
     }
-    return false;
+    const queueItem = await operator.findOne({ correlationId }, { projection: { _id: 0 } });
+    const status = queueItem && queueItem.queueItemState === QUEUE_ITEM_STATE.ABORT ? "timeout" : "unchanged";
+    return { status, queueItem };
   }
   async function checkAndSetImportJobState({ correlationId, operation, importJobState }) {
+    assertString(correlationId, "correlationId");
     logger.debug(`${correlationId}, ${importJobState}, ${operation}`);
     const timeOut = await checkTimeOut({ correlationId, operation, importJobState });
     if (timeOut) {
-      return setImportJobState({ correlationId, operation, importJobState });
+      const queueItem2 = await setImportJobState({ correlationId, operation, importJobState });
+      return { status: "updated", queueItem: queueItem2 };
     }
-    return false;
+    const queueItem = await operator.findOne({ correlationId }, { projection: { _id: 0 } });
+    const status = queueItem && queueItem.queueItemState === QUEUE_ITEM_STATE.ABORT ? "timeout" : "unchanged";
+    return { status, queueItem };
   }
   async function query(params, showParams = {}) {
     logger.debug(`Querying: ${JSON.stringify(params)}, ${JSON.stringify(showParams)}`);
@@ -184,6 +219,7 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     };
   }
   async function queryById({ correlationId, checkModTime = false }) {
+    assertString(correlationId, "correlationId");
     if (checkModTime) {
       debug(`queryById checkModTime: ${checkModTime}`);
       await checkTimeOut({ correlationId });
@@ -193,14 +229,20 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     return result;
   }
   async function checkTimeOut({ correlationId }) {
-    const { modificationTime, queueItemState: oldState, importJobState } = await operator.findOne({ 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 ([QUEUE_ITEM_STATE.ABORT, QUEUE_ITEM_STATE.ERROR, QUEUE_ITEM_STATE.DONE].includes(oldState)) {
       logger.silly(`${correlationId} has already state: ${oldState}`);
       return false;
     }
-    const timeoutTime = moment(modificationTime).add(1, "m");
+    const timeoutTime = new Date(new Date(modificationTime).getTime() + timeoutMinutes * 6e4);
     logger.silly(`${correlationId} timeOut @ ${timeoutTime}`);
-    if (timeoutTime.isBefore()) {
+    if (timeoutTime < /* @__PURE__ */ 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 });
@@ -221,25 +263,21 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     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)}`);
+    assertString(params.correlationId, "correlationId");
     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)}`);
-        return true;
-      }
+      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(clean)} from ${collection}`);
-          debug(`mongo/remove: File not found, removing queueItem ${JSON.stringify(clean)} from ${collection}`);
-          await operator.deleteOne({ correlationId: clean });
-          return true;
+          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);
@@ -250,16 +288,24 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
   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 });
+    assertString(correlationId, "correlationId");
+    const result = await operator.findOne({ correlationId });
     debug(result);
     if (result) {
       const { operationSettings } = result;
-      if (operationSettings.prio === false && operationSettings.noStream === false) {
+      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(clean)
+          // the file existence was verified by the find() above; a
+          // 'error' event on the returned stream (e.g. file deleted
+          // concurrently) is an unhandled event for the caller -> the
+          // contract is: the caller MUST attach an 'error' handler.
+          readStream: gridFSBucket.openDownloadStreamByName(correlationId)
         };
       }
       logger.debug(`OperationSettings for ${correlationId}: ${JSON.stringify(operationSettings)}`);
@@ -272,8 +318,8 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
   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();
+    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;
@@ -282,11 +328,17 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
       return true;
     }
     logger.debug(`No files for ${params.correlationId} to delete`);
-    return true;
+    return false;
   }
-  function getOne({ queueItemState, importJobState = void 0 }) {
+  async function getOne({ queueItemState, importJobState = void 0 }) {
     logger.silly(`queueItemState: ${queueItemState}, importJobState: ${JSON.stringify(importJobState)}`);
-    const cleanQueueItemState = queueItemState ? { queueItemState: sanitize(queueItemState) } : void 0;
+    if (queueItemState) {
+      assertString(queueItemState, "queueItemState");
+    }
+    if (importJobState) {
+      assertImportJobStateFilter(importJobState, "importJobState");
+    }
+    const cleanQueueItemState = queueItemState ? { queueItemState } : void 0;
     const options = { projection: { _id: 0 } };
     try {
       if (queueItemState && importJobState === void 0) {
@@ -309,51 +361,77 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
       throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
     }
   }
-  function getStream(correlationId) {
+  async function getStream(correlationId) {
     logger.info(`Forming stream from mongo for ${correlationId} in ${collection}`);
-    const clean = sanitize(correlationId);
+    assertString(correlationId, "correlationId");
     try {
-      return gridFSBucket.openDownloadStreamByName(clean);
+      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 errorMessage = error.payload || error.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)}`);
-    const clean = sanitize(correlationId);
-    await operator.updateOne({
-      correlationId: clean
-    }, {
-      $set: {
-        modificationTime: moment().toDate()
-      },
-      $push: {
-        handledIds: { $each: handledIds },
-        rejectedIds: { $each: rejectedIds }
-      }
-    });
+    try {
+      await operator.updateOne({
+        correlationId
+      }, {
+        $set: {
+          modificationTime: /* @__PURE__ */ new Date()
+        },
+        $push: {
+          handledIds: { $each: handledIds },
+          rejectedIds: { $each: rejectedIds }
+        }
+      });
+    } catch (error) {
+      const errorMessage = error.payload || error.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)}}`);
-    const clean = sanitize(correlationId);
-    const cleanMessageField = sanitize(messageField);
-    debug(`${messageField} -> ${cleanMessageField}`);
-    await operator.updateOne({
-      correlationId: clean
-    }, {
-      $set: {
-        modificationTime: moment().toDate()
-      },
-      $push: {
-        [cleanMessageField]: { $each: messages }
-      }
-    });
+    logger.silly(`Messages (${messages.length}): ${JSON.stringify(messages)}`);
+    try {
+      await operator.updateOne({
+        correlationId
+      }, {
+        $set: {
+          modificationTime: /* @__PURE__ */ new Date()
+        },
+        $push: {
+          [messageField]: { $each: messages }
+        }
+      });
+    } catch (error) {
+      const errorMessage = error.payload || error.message || "";
+      logError(error);
+      throw new ApiError(httpStatus.INTERNAL_SERVER_ERROR, `Mongo errored: ${errorMessage}`);
+    }
   }
   function setState({ correlationId, state, errorMessage = void 0, errorStatus = void 0 }) {
+    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 stateInQueueItemStates = Object.values(QUEUE_ITEM_STATE).indexOf(state) > -1;
@@ -363,76 +441,89 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
       debug(`Trying to set invalid state ${state}`);
       throw new ApiError(httpStatus.BAD_REQUEST, "Trying to set invalid state");
     }
-    const clean = sanitize(correlationId);
     const updateValues = {
       queueItemState: state,
-      modificationTime: moment().toDate(),
+      modificationTime: /* @__PURE__ */ new Date(),
       errorMessage,
       errorStatus
     };
     Object.keys(updateValues).forEach((key) => updateValues[key] === void 0 && delete updateValues[key]);
     return operator.findOneAndUpdate(
-      { correlationId: clean },
+      { correlationId },
       { $set: updateValues },
       { projection: { _id: 0 }, returnDocument: "after" }
     );
   }
   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}`);
-    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");
     }
-    if (!(cleanImportJobState in IMPORT_JOB_STATE)) {
-      debug(`Error: ${cleanImportJobState} is not in ${JSON.stringify(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, cleanImportJobState);
-    function getNewJobState(operation2, cleanImportJobState2) {
+    const newJobState = getNewJobState(operation, importJobState);
+    function getNewJobState(operation2, importJobState2) {
       if (operation2 === OPERATIONS.CREATE) {
-        return { "importJobState.CREATE": cleanImportJobState2 };
+        return { "importJobState.CREATE": importJobState2 };
       }
       if (operation2 === OPERATIONS.UPDATE) {
-        return { "importJobState.UPDATE": cleanImportJobState2 };
+        return { "importJobState.UPDATE": importJobState2 };
       }
       if (operation2 === OPERATIONS.FIX) {
-        return { "importJobState.FIX": cleanImportJobState2 };
+        return { "importJobState.FIX": importJobState2 };
       }
       throw new ApiError("400", "Invalid operation for import job state");
     }
     return operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
+      correlationId
     }, {
       $set: {
         ...newJobState,
-        modificationTime: moment().toDate()
+        modificationTime: /* @__PURE__ */ new Date()
       }
     }, { projection: { _id: 0 }, returnDocument: "after" });
   }
+  function unwrapAndUpdateResult(result, correlationId) {
+    if (result === null || result === void 0) {
+      logger.info(`Queue item ${correlationId} not found in ${collection}`);
+      throw new ApiError(httpStatus.NOT_FOUND, { message: `Job ${correlationId} not found.` });
+    }
+    return result;
+  }
   async function setOperation({ correlationId, operation }) {
+    assertString(correlationId, "correlationId");
     const newOperation = operation;
-    const { operation: oldOperation } = await operator.findOne({ correlationId });
+    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 cleanCorrelationId = sanitize(correlationId);
-    const cleanNewOperation = sanitize(newOperation);
     const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
+      correlationId
     }, {
       $set: {
-        operation: cleanNewOperation,
-        modificationTime: moment().toDate()
+        operation: newOperation,
+        modificationTime: /* @__PURE__ */ new Date()
       }
     }, { projection: { _id: 0 }, returnDocument: "after" });
     debugDev(`${JSON.stringify(result)}`);
-    return result.ok || result;
+    return unwrapAndUpdateResult(result, correlationId);
   }
   async function setOperations({ correlationId, addOperation, removeOperation = void 0 }) {
-    const cleanCorrelationId = sanitize(correlationId);
-    const queueItem = await operator.findOne({ correlationId: cleanCorrelationId });
+    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);
@@ -440,27 +531,27 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     logger.silly(`operationsAfterRemove: ${operationsAfterRemove}`);
     logger.silly(`operationAfterRemoveAndAdd: ${operationsAfterRemoveAndAdd}`);
     const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
+      correlationId
     }, {
       $set: {
         operations: operationsAfterRemoveAndAdd,
-        modificationTime: moment().toDate()
+        modificationTime: /* @__PURE__ */ new Date()
       }
     }, { projection: { _id: 0 }, returnDocument: "after" });
     debugDev(`${JSON.stringify(result)}`);
-    return result.ok || result;
+    return unwrapAndUpdateResult(result, correlationId);
   }
   async function addBlobSize({ correlationId }) {
-    const cleanCorrelationId = sanitize(correlationId);
+    assertString(correlationId, "correlationId");
     const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId,
+      correlationId,
       queueItemState: QUEUE_ITEM_STATE.VALIDATOR.WAITING_FOR_RECORDS
     }, {
       $inc: {
         blobSize: 1
       },
       $set: {
-        modificationTime: moment().toDate()
+        modificationTime: /* @__PURE__ */ new Date()
       }
     }, { projection: { _id: 0 }, returnDocument: "after" });
     logger.verbose(`AddBlobSizeResult in mongo: ${JSON.stringify(result)}`);
@@ -468,14 +559,14 @@ export default async function(MONGO_URI, collection, db = "rest-api") {
     return result;
   }
   async function setBlobSize({ correlationId, blobSize }) {
-    const cleanCorrelationId = sanitize(correlationId);
-    const cleanBlobSize = sanitize(blobSize);
+    assertString(correlationId, "correlationId");
+    assertNumber(blobSize, "blobSize");
     const result = await operator.findOneAndUpdate({
-      correlationId: cleanCorrelationId
+      correlationId
     }, {
       $set: {
-        blobSize: cleanBlobSize,
-        modificationTime: moment().toDate()
+        blobSize,
+        modificationTime: /* @__PURE__ */ new Date()
       }
     }, { projection: { _id: 0 }, returnDocument: "after" });
     logger.verbose(`SetBlobSizeResult in mongo: ${JSON.stringify(result)}`);