@prosopo/database 0.2.41 → 0.3.2

package/dist/cjs/databases/mongo.cjs

@@ -28,73 +28,82 @@ class ProsopoDatabase extends common.AsyncFactory {
     this.logger = logger;
     return this;
   }
+  getTables() {
+    if (!this.tables) {
+      throw new common.ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
+        context: { failedFuncName: this.getTables.name },
+        logger: this.logger
+      });
+    }
+    return this.tables;
+  }
+  getConnection() {
+    if (!this.connection) {
+      throw new common.ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
+        context: { failedFuncName: this.getConnection.name },
+        logger: this.logger
+      });
+    }
+    return this.connection;
+  }
   /**
    * @description Connect to the database and set the various tables
    */
   async connect() {
-    const MAX_RETRIES = 3;
-    const RETRY_INTERVAL_MS = 1e3;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        if (this.connection) {
-          return;
-        }
-        await new Promise((resolve, reject) => {
-          this.logger.info(`Mongo url: ${this.url.replace(/\w+:\w+/, "<Credentials>")}`);
-          this.connection = mongoose.createConnection(this.url, {
-            dbName: this.dbname,
-            serverApi: mongodb.ServerApiVersion.v1
-          });
-          this.tables = {
-            captcha: this.connection.models.Captcha || this.connection.model("Captcha", typesDatabase.CaptchaRecordSchema),
-            dataset: this.connection.models.Dataset || this.connection.model("Dataset", typesDatabase.DatasetRecordSchema),
-            solution: this.connection.models.Solution || this.connection.model("Solution", typesDatabase.SolutionRecordSchema),
-            commitment: this.connection.models.UserCommitment || this.connection.model("UserCommitment", typesDatabase.UserCommitmentRecordSchema),
-            usersolution: this.connection.models.UserSolution || this.connection.model("UserSolution", typesDatabase.UserSolutionRecordSchema),
-            pending: this.connection.models.Pending || this.connection.model("Pending", typesDatabase.PendingRecordSchema),
-            scheduler: this.connection.models.Scheduler || this.connection.model("Scheduler", typesDatabase.ScheduledTaskRecordSchema)
-          };
-          this.connection.once("open", resolve).on("error", (e) => {
-            var _a;
-            if (attempt === MAX_RETRIES) {
-              reject(
-                new common.ProsopoDBError("DATABASE.CONNECT_ERROR", {
-                  context: { url: this.url, error: e, attempt },
-                  logger: this.logger
-                })
-              );
-            } else {
-              (_a = this.connection) == null ? void 0 : _a.removeAllListeners("error");
-            }
-          });
-        });
-        return;
-      } catch (e) {
-        if (attempt < MAX_RETRIES) {
-          this.logger.info(`Attempt ${attempt} failed, retrying in ${RETRY_INTERVAL_MS / 1e3} seconds...`);
-          await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
-        } else {
-          throw e;
-        }
-      }
-    }
+    this.logger.info(`Mongo url: ${this.url.replace(/\w+:\w+/, "<Credentials>")}`);
+    this.connection = await new Promise((resolve, reject) => {
+      const connection = mongoose.createConnection(this.url, {
+        dbName: this.dbname,
+        serverApi: mongodb.ServerApiVersion.v1
+      });
+      connection.on("open", () => {
+        this.logger.info(`Database connection to ${this.url} opened`);
+        resolve(connection);
+      });
+      connection.on("error", (err) => {
+        this.logger.error(`Database error: ${err}`);
+        reject(err);
+      });
+      connection.on("connected", () => {
+        this.logger.info(`Database connected to ${this.url}`);
+      });
+      connection.on("disconnected", () => {
+        this.logger.info(`Database disconnected from ${this.url}`);
+      });
+      connection.on("reconnected", () => {
+        this.logger.info(`Database reconnected to ${this.url}`);
+      });
+      connection.on("reconnectFailed", () => {
+        this.logger.error(`Database reconnect failed to ${this.url}`);
+      });
+      connection.on("close", () => {
+        this.logger.info(`Database connection to ${this.url} closed`);
+      });
+      connection.on("fullsetup", () => {
+        this.logger.info(`Database connection to ${this.url} is fully setup`);
+      });
+    });
+    this.tables = {
+      captcha: this.connection.model("Captcha", typesDatabase.CaptchaRecordSchema),
+      powCaptcha: this.connection.model("PowCaptcha", typesDatabase.PowCaptchaRecordSchema),
+      dataset: this.connection.model("Dataset", typesDatabase.DatasetRecordSchema),
+      solution: this.connection.model("Solution", typesDatabase.SolutionRecordSchema),
+      commitment: this.connection.model("UserCommitment", typesDatabase.UserCommitmentRecordSchema),
+      usersolution: this.connection.model("UserSolution", typesDatabase.UserSolutionRecordSchema),
+      pending: this.connection.model("Pending", typesDatabase.PendingRecordSchema),
+      scheduler: this.connection.model("Scheduler", typesDatabase.ScheduledTaskRecordSchema)
+    };
   }
   /** Close connection to the database */
   async close() {
     this.logger.debug(`Closing connection to ${this.url}`);
-    await new Promise(async (resolve, reject) => {
-      mongoose.connection.close().then(() => {
-        this.logger.debug(`Connection to ${this.url} closed`);
-        resolve();
-      }).catch(reject);
-    });
+    await this.connection?.close();
   }
   /**
    * @description Load a dataset to the database
    * @param {Dataset}  dataset
    */
   async storeDataset(dataset) {
-    var _a, _b, _c;
     try {
       this.logger.debug(`Storing dataset in database`);
       const parsedDataset = types.DatasetWithIdsAndTreeSchema.parse(dataset);
@@ -105,21 +114,21 @@ class ProsopoDatabase extends common.AsyncFactory {
         contentTree: parsedDataset.contentTree,
         solutionTree: parsedDataset.solutionTree
       };
-      await ((_a = this.tables) == null ? void 0 : _a.dataset.updateOne(
+      await this.tables?.dataset.updateOne(
         { datasetId: parsedDataset.datasetId },
         { $set: datasetDoc },
         { upsert: true }
-      ));
+      );
       const captchaDocs = parsedDataset.captchas.map(({ solution, ...captcha }, index) => ({
         ...captcha,
         datasetId: parsedDataset.datasetId,
         datasetContentId: parsedDataset.datasetContentId,
         index,
-        solved: !!(solution == null ? void 0 : solution.length)
+        solved: !!solution?.length
       }));
       this.logger.debug(`Inserting captcha records`);
       if (captchaDocs.length) {
-        await ((_b = this.tables) == null ? void 0 : _b.captcha.bulkWrite(
+        await this.tables?.captcha.bulkWrite(
           captchaDocs.map((captchaDoc) => ({
             updateOne: {
               filter: { captchaId: captchaDoc.captchaId },
@@ -127,9 +136,9 @@ class ProsopoDatabase extends common.AsyncFactory {
               upsert: true
             }
           }))
-        ));
+        );
       }
-      const captchaSolutionDocs = parsedDataset.captchas.filter(({ solution }) => solution == null ? void 0 : solution.length).map((captcha) => ({
+      const captchaSolutionDocs = parsedDataset.captchas.filter(({ solution }) => solution?.length).map((captcha) => ({
         captchaId: captcha.captchaId,
         captchaContentId: captcha.captchaContentId,
         solution: captcha.solution,
@@ -139,7 +148,7 @@ class ProsopoDatabase extends common.AsyncFactory {
       }));
       this.logger.debug(`Inserting solution records`);
       if (captchaSolutionDocs.length) {
-        await ((_c = this.tables) == null ? void 0 : _c.solution.bulkWrite(
+        await this.tables?.solution.bulkWrite(
           captchaSolutionDocs.map((captchaSolutionDoc) => ({
             updateOne: {
               filter: { captchaId: captchaSolutionDoc.captchaId },
@@ -147,7 +156,7 @@ class ProsopoDatabase extends common.AsyncFactory {
               upsert: true
             }
           }))
-        ));
+        );
       }
       this.logger.debug(`Dataset stored in database`);
     } catch (err) {
@@ -161,20 +170,18 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string} datasetId
    */
   async getSolutions(datasetId) {
-    var _a;
-    const docs = await ((_a = this.tables) == null ? void 0 : _a.solution.find({ datasetId }).lean());
+    const docs = await this.tables?.solution.find({ datasetId }).lean();
     return docs ? docs : [];
   }
   /** @description Get a dataset from the database
    * @param {string} datasetId
    */
   async getDataset(datasetId) {
-    var _a, _b, _c;
-    const datasetDoc = await ((_a = this.tables) == null ? void 0 : _a.dataset.findOne({ datasetId }).lean());
+    const datasetDoc = await this.tables?.dataset.findOne({ datasetId }).lean();
     if (datasetDoc) {
       const { datasetContentId, format, contentTree, solutionTree } = datasetDoc;
-      const captchas = await ((_b = this.tables) == null ? void 0 : _b.captcha.find({ datasetId }).lean()) || [];
-      const solutions = await ((_c = this.tables) == null ? void 0 : _c.solution.find({ datasetId }).lean()) || [];
+      const captchas = await this.tables?.captcha.find({ datasetId }).lean() || [];
+      const solutions = await this.tables?.solution.find({ datasetId }).lean() || [];
       const solutionsKeyed = {};
       for (const solution of solutions) {
         solutionsKeyed[solution.captchaId] = solution;
@@ -211,14 +218,13 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {number}   size       the number of records to be returned
    */
   async getRandomCaptcha(solved, datasetId, size) {
-    var _a;
     if (!is.isHex(datasetId)) {
       throw new common.ProsopoDBError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.getRandomCaptcha.name, datasetId }
       });
     }
     const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
-    const cursor = (_a = this.tables) == null ? void 0 : _a.captcha.aggregate([
+    const cursor = this.tables?.captcha.aggregate([
       { $match: { datasetId, solved } },
       { $sample: { size: sampleSize } },
       {
@@ -245,8 +251,7 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} captchaId
    */
   async getCaptchaById(captchaId) {
-    var _a;
-    const cursor = (_a = this.tables) == null ? void 0 : _a.captcha.find({ captchaId: { $in: captchaId } }).lean();
+    const cursor = this.tables?.captcha.find({ captchaId: { $in: captchaId } }).lean();
     const docs = await cursor;
     if (docs && docs.length) {
       return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
@@ -261,14 +266,13 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string}   datasetId  the id of the data set
    */
   async updateCaptcha(captcha, datasetId) {
-    var _a;
     if (!is.isHex(datasetId)) {
       throw new common.ProsopoDBError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.updateCaptcha.name, datasetId }
       });
     }
     try {
-      await ((_a = this.tables) == null ? void 0 : _a.captcha.updateOne({ datasetId }, { $set: captcha }, { upsert: false }));
+      await this.tables?.captcha.updateOne({ datasetId }, { $set: captcha }, { upsert: false });
     } catch (err) {
       throw new common.ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
         context: { failedFuncName: this.getDatasetDetails.name, error: err }
@@ -279,20 +283,18 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @description Remove captchas
    */
   async removeCaptchas(captchaIds) {
-    var _a;
-    await ((_a = this.tables) == null ? void 0 : _a.captcha.deleteMany({ captchaId: { $in: captchaIds } }));
+    await this.tables?.captcha.deleteMany({ captchaId: { $in: captchaIds } });
   }
   /**
    * @description Get a dataset by Id
    */
   async getDatasetDetails(datasetId) {
-    var _a;
     if (!is.isHex(datasetId)) {
       throw new common.ProsopoDBError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.getDatasetDetails.name, datasetId }
       });
     }
-    const doc = await ((_a = this.tables) == null ? void 0 : _a.dataset.findOne({ datasetId }).lean());
+    const doc = await this.tables?.dataset.findOne({ datasetId }).lean();
     if (doc) {
       return doc;
     }
@@ -304,16 +306,15 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @description Store a Dapp User's captcha solution commitment
    */
   async storeDappUserSolution(captchas, commit) {
-    var _a, _b;
     const commitmentRecord = typesDatabase.UserCommitmentSchema.parse(commit);
     if (captchas.length) {
-      await ((_a = this.tables) == null ? void 0 : _a.commitment.updateOne(
+      await this.tables?.commitment.updateOne(
         {
           id: commit.id
         },
         commitmentRecord,
         { upsert: true }
-      ));
+      );
       const ops = captchas.map((captcha) => ({
         updateOne: {
           filter: { commitmentId: commit.id, captchaId: captcha.captchaId },
@@ -330,54 +331,136 @@ class ProsopoDatabase extends common.AsyncFactory {
           upsert: true
         }
       }));
-      await ((_b = this.tables) == null ? void 0 : _b.usersolution.bulkWrite(ops));
+      await this.tables?.usersolution.bulkWrite(ops);
+    }
+  }
+  /**
+   * @description Adds a new PoW Captcha record to the database.
+   * @param {string} challenge The challenge string for the captcha.
+   * @param {boolean} checked Indicates if the captcha has been checked.
+   * @returns {Promise<void>} A promise that resolves when the record is added.
+   */
+  async storePowCaptchaRecord(challenge, checked) {
+    if (!this.tables) {
+      throw new common.ProsopoEnvError("DATABASE.DATABASE_UNDEFINED", {
+        context: { failedFuncName: this.storePowCaptchaRecord.name },
+        logger: this.logger
+      });
+    }
+    const powCaptchaRecord = {
+      challenge,
+      checked
+    };
+    try {
+      await this.tables.powCaptcha.create(powCaptchaRecord);
+      this.logger.info("PowCaptcha record added successfully", { challenge, checked });
+    } catch (error) {
+      this.logger.error("Failed to add PowCaptcha record", { error, challenge, checked });
+      throw new common.ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+        context: { error, challenge, checked },
+        logger: this.logger
+      });
+    }
+  }
+  /**
+   * @description Retrieves a PoW Captcha record by its challenge string.
+   * @param {string} challenge The challenge string to search for.
+   * @returns {Promise<PowCaptcha | null>} A promise that resolves with the found record or null if not found.
+   */
+  async getPowCaptchaRecordByChallenge(challenge) {
+    if (!this.tables) {
+      throw new common.ProsopoEnvError("DATABASE.DATABASE_UNDEFINED", {
+        context: { failedFuncName: this.getPowCaptchaRecordByChallenge.name },
+        logger: this.logger
+      });
+    }
+    try {
+      const record = await this.tables.powCaptcha.findOne({ challenge }).lean();
+      if (record) {
+        this.logger.info("PowCaptcha record retrieved successfully", { challenge });
+        return record;
+      } else {
+        this.logger.info("No PowCaptcha record found", { challenge });
+        return null;
+      }
+    } catch (error) {
+      this.logger.error("Failed to retrieve PowCaptcha record", { error, challenge });
+      throw new common.ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+        context: { error, challenge },
+        logger: this.logger
+      });
+    }
+  }
+  /**
+   * @description Updates a PoW Captcha record in the database.
+   * @param {string} challenge The challenge string of the captcha to be updated.
+   * @param {boolean} checked New value indicating whether the captcha has been checked.
+   * @returns {Promise<void>} A promise that resolves when the record is updated.
+   */
+  async updatePowCaptchaRecord(challenge, checked) {
+    if (!this.tables) {
+      throw new common.ProsopoEnvError("DATABASE.DATABASE_UNDEFINED", {
+        context: { failedFuncName: this.updatePowCaptchaRecord.name },
+        logger: this.logger
+      });
+    }
+    try {
+      const updateResult = await this.tables.powCaptcha.updateOne({ challenge }, { $set: { checked } });
+      if (updateResult.matchedCount === 0) {
+        this.logger.info("No PowCaptcha record found to update", { challenge, checked });
+        throw new common.ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+          context: { challenge, checked },
+          logger: this.logger
+        });
+      } else {
+        this.logger.info("PowCaptcha record updated successfully", { challenge, checked });
+      }
+    } catch (error) {
+      this.logger.error("Failed to update PowCaptcha record", { error, challenge, checked });
+      throw new common.ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+        context: { error, challenge, checked },
+        logger: this.logger
+      });
     }
   }
   /** @description Get processed Dapp User captcha solutions from the user solution table
    */
   async getProcessedDappUserSolutions() {
-    var _a;
-    const docs = await ((_a = this.tables) == null ? void 0 : _a.usersolution.find({ processed: true }).lean());
+    const docs = await this.tables?.usersolution.find({ processed: true }).lean();
     return docs ? docs.map((doc) => typesDatabase.UserSolutionSchema.parse(doc)) : [];
   }
   /** @description Get processed Dapp User captcha commitments from the commitments table
    */
   async getProcessedDappUserCommitments() {
-    var _a;
-    const docs = await ((_a = this.tables) == null ? void 0 : _a.commitment.find({ processed: true }).lean());
+    const docs = await this.tables?.commitment.find({ processed: true }).lean();
     return docs ? docs.map((doc) => typesDatabase.UserCommitmentSchema.parse(doc)) : [];
   }
   /** @description Get Dapp User captcha commitments from the commitments table that have not been batched on-chain
    */
   async getUnbatchedDappUserCommitments() {
-    var _a;
-    const docs = await ((_a = this.tables) == null ? void 0 : _a.commitment.find({ batched: false }).lean());
+    const docs = await this.tables?.commitment.find({ batched: false }).lean();
     return docs ? docs.map((doc) => typesDatabase.UserCommitmentSchema.parse(doc)) : [];
   }
   /** @description Get Dapp User captcha commitments from the commitments table that have been batched on-chain
    */
   async getBatchedDappUserCommitments() {
-    var _a;
-    const docs = await ((_a = this.tables) == null ? void 0 : _a.commitment.find({ batched: true }).lean());
+    const docs = await this.tables?.commitment.find({ batched: true }).lean();
     return docs ? docs.map((doc) => typesDatabase.UserCommitmentSchema.parse(doc)) : [];
   }
   /** @description Remove processed Dapp User captcha solutions from the user solution table
    */
   async removeProcessedDappUserSolutions(commitmentIds) {
-    var _a;
-    return await ((_a = this.tables) == null ? void 0 : _a.usersolution.deleteMany({ processed: true, commitmentId: { $in: commitmentIds } }));
+    return await this.tables?.usersolution.deleteMany({ processed: true, commitmentId: { $in: commitmentIds } });
   }
   /** @description Remove processed Dapp User captcha commitments from the user commitments table
    */
   async removeProcessedDappUserCommitments(commitmentIds) {
-    var _a;
-    return await ((_a = this.tables) == null ? void 0 : _a.commitment.deleteMany({ processed: true, id: { $in: commitmentIds } }));
+    return await this.tables?.commitment.deleteMany({ processed: true, id: { $in: commitmentIds } });
   }
   /**
    * @description Store a Dapp User's pending record
    */
   async storeDappUserPending(userAccount, requestHash, salt, deadlineTimestamp, requestedAtBlock) {
-    var _a;
     if (!is.isHex(requestHash)) {
       throw new common.ProsopoDBError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.storeDappUserPending.name, requestHash }
@@ -391,19 +474,18 @@ class ProsopoDatabase extends common.AsyncFactory {
       deadlineTimestamp,
       requestedAtBlock
     };
-    await ((_a = this.tables) == null ? void 0 : _a.pending.updateOne({ requestHash }, { $set: pendingRecord }, { upsert: true }));
+    await this.tables?.pending.updateOne({ requestHash }, { $set: pendingRecord }, { upsert: true });
   }
   /**
    * @description Get a Dapp user's pending record
    */
   async getDappUserPending(requestHash) {
-    var _a;
     if (!is.isHex(requestHash)) {
       throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.getDappUserPending.name, requestHash }
       });
     }
-    const doc = await ((_a = this.tables) == null ? void 0 : _a.pending.findOne({ requestHash }).lean());
+    const doc = await this.tables?.pending.findOne({ requestHash }).lean();
     if (doc) {
       return doc;
     }
@@ -415,13 +497,12 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @description Update a Dapp User's pending record
    */
   async updateDappUserPendingStatus(userAccount, requestHash, approve) {
-    var _a;
     if (!is.isHex(requestHash)) {
       throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.updateDappUserPendingStatus.name, requestHash }
       });
     }
-    await ((_a = this.tables) == null ? void 0 : _a.pending.updateOne(
+    await this.tables?.pending.updateOne(
       { requestHash },
       {
         $set: {
@@ -432,14 +513,13 @@ class ProsopoDatabase extends common.AsyncFactory {
         }
       },
       { upsert: true }
-    ));
+    );
   }
   /**
    * @description Get all unsolved captchas
    */
   async getAllCaptchasByDatasetId(datasetId, state) {
-    var _a;
-    const cursor = (_a = this.tables) == null ? void 0 : _a.captcha.find({
+    const cursor = this.tables?.captcha.find({
       datasetId,
       solved: state === types.CaptchaStates.Solved
     }).lean();
@@ -453,8 +533,7 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @description Get all dapp user solutions by captchaIds
    */
   async getAllDappUserSolutions(captchaId) {
-    var _a, _b;
-    const cursor = (_b = (_a = this.tables) == null ? void 0 : _a.usersolution) == null ? void 0 : _b.find({ captchaId: { $in: captchaId } }).lean();
+    const cursor = this.tables?.usersolution?.find({ captchaId: { $in: captchaId } }).lean();
     const docs = await cursor;
     if (docs) {
       return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
@@ -462,8 +541,7 @@ class ProsopoDatabase extends common.AsyncFactory {
     throw new common.ProsopoEnvError("DATABASE.SOLUTION_GET_FAILED");
   }
   async getDatasetIdWithSolvedCaptchasOfSizeN(solvedCaptchaCount) {
-    var _a;
-    const cursor = (_a = this.tables) == null ? void 0 : _a.solution.aggregate([
+    const cursor = this.tables?.solution.aggregate([
       {
         $match: {}
       },
@@ -489,14 +567,13 @@ class ProsopoDatabase extends common.AsyncFactory {
     throw new common.ProsopoDBError("DATABASE.DATASET_WITH_SOLUTIONS_GET_FAILED");
   }
   async getRandomSolvedCaptchasFromSingleDataset(datasetId, size) {
-    var _a;
     if (!is.isHex(datasetId)) {
       throw new common.ProsopoDBError("DATABASE.INVALID_HASH", {
         context: { failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name, datasetId }
       });
     }
     const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
-    const cursor = (_a = this.tables) == null ? void 0 : _a.solution.aggregate([
+    const cursor = this.tables?.solution.aggregate([
       { $match: { datasetId } },
       { $sample: { size: sampleSize } },
       {
@@ -520,8 +597,7 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} commitmentId
    */
   async getDappUserSolutionById(commitmentId) {
-    var _a, _b;
-    const cursor = (_b = (_a = this.tables) == null ? void 0 : _a.usersolution) == null ? void 0 : _b.findOne(
+    const cursor = this.tables?.usersolution?.findOne(
       {
         commitmentId
       },
@@ -540,8 +616,7 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param commitmentId
    */
   async getDappUserCommitmentById(commitmentId) {
-    var _a, _b;
-    const commitmentCursor = (_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.findOne({ id: commitmentId }).lean();
+    const commitmentCursor = this.tables?.commitment?.findOne({ id: commitmentId }).lean();
     const doc = await commitmentCursor;
     return doc ? typesDatabase.UserCommitmentSchema.parse(doc) : void 0;
   }
@@ -550,8 +625,7 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} userAccount
    */
   async getDappUserCommitmentByAccount(userAccount) {
-    var _a, _b;
-    const docs = await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.find({ userAccount }).lean());
+    const docs = await this.tables?.commitment?.find({ userAccount }).lean();
     return docs ? docs : [];
   }
   /**
@@ -559,13 +633,12 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} commitmentId
    */
   async approveDappUserCommitment(commitmentId) {
-    var _a, _b;
     try {
-      await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.findOneAndUpdate(
+      await this.tables?.commitment?.findOneAndUpdate(
         { id: commitmentId },
         { $set: { status: typesReturns.CaptchaStatus.approved } },
         { upsert: false }
-      ).lean());
+      ).lean();
     } catch (err) {
       throw new common.ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", { context: { error: err, commitmentId } });
     }
@@ -575,9 +648,8 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} captchaIds
    */
   async flagProcessedDappUserSolutions(captchaIds) {
-    var _a, _b;
     try {
-      await ((_b = (_a = this.tables) == null ? void 0 : _a.usersolution) == null ? void 0 : _b.updateMany({ captchaId: { $in: captchaIds } }, { $set: { processed: true } }, { upsert: false }).lean());
+      await this.tables?.usersolution?.updateMany({ captchaId: { $in: captchaIds } }, { $set: { processed: true } }, { upsert: false }).lean();
     } catch (err) {
       throw new common.ProsopoDBError("DATABASE.SOLUTION_FLAG_FAILED", { context: { error: err, captchaIds } });
     }
@@ -587,10 +659,9 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} commitmentIds
    */
   async flagProcessedDappUserCommitments(commitmentIds) {
-    var _a, _b;
     try {
       const distinctCommitmentIds = [...new Set(commitmentIds)];
-      await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { processed: true } }, { upsert: false }).lean());
+      await this.tables?.commitment?.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { processed: true } }, { upsert: false }).lean();
     } catch (err) {
       throw new common.ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", { context: { error: err, commitmentIds } });
     }
@@ -600,10 +671,9 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @param {string[]} commitmentIds
    */
   async flagBatchedDappUserCommitments(commitmentIds) {
-    var _a, _b;
     try {
       const distinctCommitmentIds = [...new Set(commitmentIds)];
-      await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { batched: true } }, { upsert: false }).lean());
+      await this.tables?.commitment?.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { batched: true } }, { upsert: false }).lean();
     } catch (err) {
       throw new common.ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", { context: { error: err, commitmentIds } });
     }
@@ -612,9 +682,8 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @description Get the last batch commit time or return 0 if none
    */
   async getLastBatchCommitTime() {
-    var _a, _b;
-    const cursor = (_b = (_a = this.tables) == null ? void 0 : _a.scheduler) == null ? void 0 : _b.findOne({ processName: types.ScheduledTaskNames.BatchCommitment, status: types.ScheduledTaskStatus.Completed }).sort({ timestamp: -1 });
-    const doc = await (cursor == null ? void 0 : cursor.lean());
+    const cursor = this.tables?.scheduler?.findOne({ processName: types.ScheduledTaskNames.BatchCommitment, status: types.ScheduledTaskStatus.Completed }).sort({ timestamp: -1 });
+    const doc = await cursor?.lean();
     if (doc) {
       return doc.datetime;
     }
@@ -624,27 +693,24 @@ class ProsopoDatabase extends common.AsyncFactory {
    * @description Get a scheduled task status record by task ID and status
    */
   async getScheduledTaskStatus(taskId, status) {
-    var _a, _b;
-    const cursor = await ((_b = (_a = this.tables) == null ? void 0 : _a.scheduler) == null ? void 0 : _b.findOne({ taskId, status }).lean());
+    const cursor = await this.tables?.scheduler?.findOne({ taskId, status }).lean();
     return cursor ? cursor : void 0;
   }
   /**
    * @description Get the most recent scheduled task status record for a given task
    */
   async getLastScheduledTaskStatus(task, status) {
-    var _a, _b;
     const lookup = { processName: task };
     if (status) {
       lookup["status"] = status;
     }
-    const cursor = await ((_b = (_a = this.tables) == null ? void 0 : _a.scheduler) == null ? void 0 : _b.findOne(lookup).sort({ datetime: -1 }).lean());
+    const cursor = await this.tables?.scheduler?.findOne(lookup).sort({ datetime: -1 }).lean();
     return cursor ? cursor : void 0;
   }
   /**
    * @description Store the status of a scheduled task and an optional result
    */
   async storeScheduledTaskStatus(taskId, task, status, result) {
-    var _a;
     const now = /* @__PURE__ */ new Date();
     const doc = typesDatabase.ScheduledTaskSchema.parse({
       taskId,
@@ -653,7 +719,7 @@ class ProsopoDatabase extends common.AsyncFactory {
       status,
       ...result && { result }
     });
-    await ((_a = this.tables) == null ? void 0 : _a.scheduler.create(doc));
+    await this.tables?.scheduler.create(doc);
   }
 }
 exports.ProsopoDatabase = ProsopoDatabase;