@prosopo/database 1.0.2 → 2.0.1

package/dist/databases/mongo.js

@@ -1,17 +1,16 @@
-import { AsyncFactory, ProsopoDBError, ProsopoEnvError, getLoggerDefault } from '@prosopo/common';
-import { CaptchaStates, DatasetWithIdsAndTreeSchema, ScheduledTaskNames, ScheduledTaskStatus, } from '@prosopo/types';
-import { CaptchaRecordSchema, DatasetRecordSchema, PendingRecordSchema, PowCaptchaRecordSchema, ScheduledTaskRecordSchema, ScheduledTaskSchema, SolutionRecordSchema, UserCommitmentRecordSchema, UserCommitmentSchema, UserSolutionRecordSchema, UserSolutionSchema, } from '@prosopo/types-database';
-import { CaptchaStatus } from '@prosopo/captcha-contract/types-returns';
-import { ServerApiVersion } from 'mongodb';
-import { isHex } from '@polkadot/util/is';
-import mongoose from 'mongoose';
-mongoose.set('strictQuery', false);
-const DEFAULT_ENDPOINT = 'mongodb://127.0.0.1:27017';
+import { isHex } from "@polkadot/util/is";
+import { AsyncFactory, ProsopoDBError, ProsopoEnvError, getLoggerDefault, } from "@prosopo/common";
+import { CaptchaStates, CaptchaStatus, DatasetWithIdsAndTreeSchema, ScheduledTaskNames, ScheduledTaskStatus, } from "@prosopo/types";
+import { CaptchaRecordSchema, DatasetRecordSchema, PendingRecordSchema, PowCaptchaRecordSchema, ScheduledTaskRecordSchema, ScheduledTaskSchema, SolutionRecordSchema, UserCommitmentRecordSchema, UserCommitmentSchema, UserSolutionRecordSchema, UserSolutionSchema, } from "@prosopo/types-database";
+import { ServerApiVersion } from "mongodb";
+import mongoose from "mongoose";
+mongoose.set("strictQuery", false);
+const DEFAULT_ENDPOINT = "mongodb://127.0.0.1:27017";
 export class ProsopoDatabase extends AsyncFactory {
     constructor() {
         super();
-        this.url = '';
-        this.dbname = '';
+        this.url = "";
+        this.dbname = "";
         this.logger = getLoggerDefault();
     }
     async init(url, dbname, logger, authSource) {
@@ -19,7 +18,7 @@ export class ProsopoDatabase extends AsyncFactory {
         const parsedUrl = new URL(baseEndpoint);
         parsedUrl.pathname = dbname;
         if (authSource) {
-            parsedUrl.searchParams.set('authSource', authSource);
+            parsedUrl.searchParams.set("authSource", authSource);
         }
         this.url = parsedUrl.toString();
         this.dbname = dbname;
@@ -28,7 +27,7 @@ export class ProsopoDatabase extends AsyncFactory {
     }
     getTables() {
         if (!this.tables) {
-            throw new ProsopoDBError('DATABASE.TABLES_UNDEFINED', {
+            throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
                 context: { failedFuncName: this.getTables.name },
                 logger: this.logger,
             });
@@ -37,7 +36,7 @@ export class ProsopoDatabase extends AsyncFactory {
     }
     getConnection() {
         if (!this.connection) {
-            throw new ProsopoDBError('DATABASE.CONNECTION_UNDEFINED', {
+            throw new ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
                 context: { failedFuncName: this.getConnection.name },
                 logger: this.logger,
             });
@@ -45,48 +44,51 @@ export class ProsopoDatabase extends AsyncFactory {
         return this.connection;
     }
     async connect() {
-        this.logger.info(`Mongo url: ${this.url.replace(/\w+:\w+/, '<Credentials>')}`);
+        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: ServerApiVersion.v1,
             });
-            connection.on('open', () => {
+            connection.on("open", () => {
                 this.logger.info(`Database connection to ${this.url} opened`);
                 resolve(connection);
             });
-            connection.on('error', (err) => {
+            connection.on("error", (err) => {
                 this.logger.error(`Database error: ${err}`);
                 reject(err);
             });
-            connection.on('connected', () => {
+            connection.on("connected", () => {
                 this.logger.info(`Database connected to ${this.url}`);
+                resolve(connection);
             });
-            connection.on('disconnected', () => {
+            connection.on("disconnected", () => {
                 this.logger.info(`Database disconnected from ${this.url}`);
             });
-            connection.on('reconnected', () => {
+            connection.on("reconnected", () => {
                 this.logger.info(`Database reconnected to ${this.url}`);
+                resolve(connection);
             });
-            connection.on('reconnectFailed', () => {
+            connection.on("reconnectFailed", () => {
                 this.logger.error(`Database reconnect failed to ${this.url}`);
             });
-            connection.on('close', () => {
+            connection.on("close", () => {
                 this.logger.info(`Database connection to ${this.url} closed`);
             });
-            connection.on('fullsetup', () => {
+            connection.on("fullsetup", () => {
                 this.logger.info(`Database connection to ${this.url} is fully setup`);
+                resolve(connection);
             });
         });
         this.tables = {
-            captcha: this.connection.model('Captcha', CaptchaRecordSchema),
-            powCaptcha: this.connection.model('PowCaptcha', PowCaptchaRecordSchema),
-            dataset: this.connection.model('Dataset', DatasetRecordSchema),
-            solution: this.connection.model('Solution', SolutionRecordSchema),
-            commitment: this.connection.model('UserCommitment', UserCommitmentRecordSchema),
-            usersolution: this.connection.model('UserSolution', UserSolutionRecordSchema),
-            pending: this.connection.model('Pending', PendingRecordSchema),
-            scheduler: this.connection.model('Scheduler', ScheduledTaskRecordSchema),
+            captcha: this.connection.model("Captcha", CaptchaRecordSchema),
+            powCaptcha: this.connection.model("PowCaptcha", PowCaptchaRecordSchema),
+            dataset: this.connection.model("Dataset", DatasetRecordSchema),
+            solution: this.connection.model("Solution", SolutionRecordSchema),
+            commitment: this.connection.model("UserCommitment", UserCommitmentRecordSchema),
+            usersolution: this.connection.model("UserSolution", UserSolutionRecordSchema),
+            pending: this.connection.model("Pending", PendingRecordSchema),
+            scheduler: this.connection.model("Scheduler", ScheduledTaskRecordSchema),
         };
     }
     async close() {
@@ -95,7 +97,7 @@ export class ProsopoDatabase extends AsyncFactory {
     }
     async storeDataset(dataset) {
         try {
-            this.logger.debug(`Storing dataset in database`);
+            this.logger.debug("Storing dataset in database");
             const parsedDataset = DatasetWithIdsAndTreeSchema.parse(dataset);
             const datasetDoc = {
                 datasetId: parsedDataset.datasetId,
@@ -112,7 +114,7 @@ export class ProsopoDatabase extends AsyncFactory {
                 index,
                 solved: !!solution?.length,
             }));
-            this.logger.debug(`Inserting captcha records`);
+            this.logger.debug("Inserting captcha records");
             if (captchaDocs.length) {
                 await this.tables?.captcha.bulkWrite(captchaDocs.map((captchaDoc) => ({
                     updateOne: {
@@ -132,7 +134,7 @@ export class ProsopoDatabase extends AsyncFactory {
                 datasetId: parsedDataset.datasetId,
                 datasetContentId: parsedDataset.datasetContentId,
             }));
-            this.logger.debug(`Inserting solution records`);
+            this.logger.debug("Inserting solution records");
             if (captchaSolutionDocs.length) {
                 await this.tables?.solution.bulkWrite(captchaSolutionDocs.map((captchaSolutionDoc) => ({
                     updateOne: {
@@ -142,23 +144,23 @@ export class ProsopoDatabase extends AsyncFactory {
                     },
                 })));
             }
-            this.logger.debug(`Dataset stored in database`);
+            this.logger.debug("Dataset stored in database");
         }
         catch (err) {
-            throw new ProsopoDBError('DATABASE.DATASET_LOAD_FAILED', {
+            throw new ProsopoDBError("DATABASE.DATASET_LOAD_FAILED", {
                 context: { failedFuncName: this.storeDataset.name, error: err },
                 logger: this.logger,
             });
         }
     }
     async getSolutions(datasetId) {
-        const docs = await this.tables?.solution.find({ datasetId }).lean();
+        const docs = await this.tables?.solution
+            .find({ datasetId })
+            .lean();
         return docs ? docs : [];
     }
     async getDataset(datasetId) {
-        const datasetDoc = await this.tables?.dataset
-            .findOne({ datasetId: datasetId })
-            .lean();
+        const datasetDoc = await this.tables?.dataset.findOne({ datasetId: datasetId }).lean();
         if (datasetDoc) {
             const { datasetContentId, format, contentTree, solutionTree } = datasetDoc;
             const captchas = (await this.tables?.captcha.find({ datasetId }).lean()) || [];
@@ -188,13 +190,13 @@ export class ProsopoDatabase extends AsyncFactory {
                 }),
             };
         }
-        throw new ProsopoDBError('DATABASE.DATASET_GET_FAILED', {
+        throw new ProsopoDBError("DATABASE.DATASET_GET_FAILED", {
             context: { failedFuncName: this.getDataset.name, datasetId },
         });
     }
     async getRandomCaptcha(solved, datasetId, size) {
         if (!isHex(datasetId)) {
-            throw new ProsopoDBError('DATABASE.INVALID_HASH', {
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
                 context: { failedFuncName: this.getRandomCaptcha.name, datasetId },
             });
         }
@@ -214,26 +216,33 @@ export class ProsopoDatabase extends AsyncFactory {
             },
         ]);
         const docs = await cursor;
-        if (docs && docs.length) {
+        if (docs?.length) {
             return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
         }
-        throw new ProsopoDBError('DATABASE.CAPTCHA_GET_FAILED', {
-            context: { failedFuncName: this.getRandomCaptcha.name, solved, datasetId, size },
+        throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+            context: {
+                failedFuncName: this.getRandomCaptcha.name,
+                solved,
+                datasetId,
+                size,
+            },
         });
     }
     async getCaptchaById(captchaId) {
-        const cursor = this.tables?.captcha.find({ captchaId: { $in: captchaId } }).lean();
+        const cursor = this.tables?.captcha
+            .find({ captchaId: { $in: captchaId } })
+            .lean();
         const docs = await cursor;
-        if (docs && docs.length) {
+        if (docs?.length) {
             return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
         }
-        throw new ProsopoDBError('DATABASE.CAPTCHA_GET_FAILED', {
+        throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
             context: { failedFuncName: this.getCaptchaById.name, captchaId },
         });
     }
     async updateCaptcha(captcha, datasetId) {
         if (!isHex(datasetId)) {
-            throw new ProsopoDBError('DATABASE.INVALID_HASH', {
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
                 context: { failedFuncName: this.updateCaptcha.name, datasetId },
             });
         }
@@ -241,7 +250,7 @@ export class ProsopoDatabase extends AsyncFactory {
             await this.tables?.captcha.updateOne({ datasetId }, { $set: captcha }, { upsert: false });
         }
         catch (err) {
-            throw new ProsopoDBError('DATABASE.CAPTCHA_UPDATE_FAILED', {
+            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
                 context: { failedFuncName: this.getDatasetDetails.name, error: err },
             });
         }
@@ -251,16 +260,21 @@ export class ProsopoDatabase extends AsyncFactory {
     }
     async getDatasetDetails(datasetId) {
         if (!isHex(datasetId)) {
-            throw new ProsopoDBError('DATABASE.INVALID_HASH', {
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
                 context: { failedFuncName: this.getDatasetDetails.name, datasetId },
             });
         }
-        const doc = await this.tables?.dataset.findOne({ datasetId }).lean();
+        const doc = await this.tables?.dataset
+            .findOne({ datasetId })
+            .lean();
         if (doc) {
             return doc;
         }
-        throw new ProsopoDBError('DATABASE.DATASET_GET_FAILED', {
-            context: { failedFuncName: this.getDatasetDetails.name, datasetId },
+        throw new ProsopoDBError("DATABASE.DATASET_GET_FAILED", {
+            context: {
+                failedFuncName: this.getDatasetDetails.name,
+                datasetId,
+            },
         });
     }
     async storeDappUserSolution(captchas, commit) {
@@ -288,24 +302,29 @@ export class ProsopoDatabase extends AsyncFactory {
             await this.tables?.usersolution.bulkWrite(ops);
         }
     }
-    async storePowCaptchaRecord(challenge, checked) {
-        if (!this.tables) {
-            throw new ProsopoEnvError('DATABASE.DATABASE_UNDEFINED', {
-                context: { failedFuncName: this.storePowCaptchaRecord.name },
-                logger: this.logger,
-            });
-        }
+    async storePowCaptchaRecord(challenge, components, checked, stored = false) {
+        const tables = this.getTables();
         const powCaptchaRecord = {
             challenge,
+            ...components,
             checked,
+            stored
         };
         try {
-            await this.tables.powCaptcha.create(powCaptchaRecord);
-            this.logger.info('PowCaptcha record added successfully', { challenge, checked });
+            await tables.powCaptcha.create(powCaptchaRecord);
+            this.logger.info("PowCaptcha record added successfully", {
+                challenge,
+                checked,
+                stored
+            });
         }
         catch (error) {
-            this.logger.error('Failed to add PowCaptcha record', { error, challenge, checked });
-            throw new ProsopoDBError('DATABASE.CAPTCHA_UPDATE_FAILED', {
+            this.logger.error("Failed to add PowCaptcha record", {
+                error,
+                challenge,
+                checked,
+            });
+            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
                 context: { error, challenge, checked },
                 logger: this.logger,
             });
@@ -313,60 +332,70 @@ export class ProsopoDatabase extends AsyncFactory {
     }
     async getPowCaptchaRecordByChallenge(challenge) {
         if (!this.tables) {
-            throw new ProsopoEnvError('DATABASE.DATABASE_UNDEFINED', {
+            throw new ProsopoEnvError("DATABASE.DATABASE_UNDEFINED", {
                 context: { failedFuncName: this.getPowCaptchaRecordByChallenge.name },
                 logger: this.logger,
             });
         }
         try {
-            const record = await this.tables.powCaptcha.findOne({ challenge }).lean();
+            const record = await this.tables.powCaptcha
+                .findOne({ challenge })
+                .lean();
             if (record) {
-                this.logger.info('PowCaptcha record retrieved successfully', { challenge });
+                this.logger.info("PowCaptcha record retrieved successfully", {
+                    challenge,
+                });
                 return record;
             }
-            else {
-                this.logger.info('No PowCaptcha record found', { challenge });
-                return null;
-            }
+            this.logger.info("No PowCaptcha record found", { challenge });
+            return null;
         }
         catch (error) {
-            this.logger.error('Failed to retrieve PowCaptcha record', { error, challenge });
-            throw new ProsopoDBError('DATABASE.CAPTCHA_GET_FAILED', {
+            this.logger.error("Failed to retrieve PowCaptcha record", {
+                error,
+                challenge,
+            });
+            throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
                 context: { error, challenge },
                 logger: this.logger,
             });
         }
     }
     async updatePowCaptchaRecord(challenge, checked) {
-        if (!this.tables) {
-            throw new ProsopoEnvError('DATABASE.DATABASE_UNDEFINED', {
-                context: { failedFuncName: this.updatePowCaptchaRecord.name },
-                logger: this.logger,
-            });
-        }
+        const tables = this.getTables();
         try {
-            const updateResult = await this.tables.powCaptcha.updateOne({ challenge }, { $set: { checked } });
+            const updateResult = await tables.powCaptcha.updateOne({ challenge }, { $set: { checked } });
             if (updateResult.matchedCount === 0) {
-                this.logger.info('No PowCaptcha record found to update', { challenge, checked });
-                throw new ProsopoDBError('DATABASE.CAPTCHA_GET_FAILED', {
+                this.logger.info("No PowCaptcha record found to update", {
+                    challenge,
+                    checked,
+                });
+                throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
                     context: { challenge, checked },
                     logger: this.logger,
                 });
             }
-            else {
-                this.logger.info('PowCaptcha record updated successfully', { challenge, checked });
-            }
+            this.logger.info("PowCaptcha record updated successfully", {
+                challenge,
+                checked,
+            });
         }
         catch (error) {
-            this.logger.error('Failed to update PowCaptcha record', { error, challenge, checked });
-            throw new ProsopoDBError('DATABASE.CAPTCHA_UPDATE_FAILED', {
+            this.logger.error("Failed to update PowCaptcha record", {
+                error,
+                challenge,
+                checked,
+            });
+            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
                 context: { error, challenge, checked },
                 logger: this.logger,
             });
         }
     }
     async getProcessedDappUserSolutions() {
-        const docs = await this.tables?.usersolution.find({ processed: true }).lean();
+        const docs = await this.tables?.usersolution
+            .find({ processed: true })
+            .lean();
         return docs ? docs.map((doc) => UserSolutionSchema.parse(doc)) : [];
     }
     async getProcessedDappUserCommitments() {
@@ -388,20 +417,40 @@ export class ProsopoDatabase extends AsyncFactory {
     async markDappUserCommitmentsStored(commitmentIds) {
         await this.tables?.commitment.updateMany({ id: { $in: commitmentIds } }, { $set: { stored: true } }, { upsert: false });
     }
+    async getUnstoredDappUserPoWCommitments() {
+        const docs = await this.tables?.powCaptcha
+            .find({
+            $or: [{ stored: false }, { stored: { $exists: false } }],
+        })
+            .lean();
+        return docs || [];
+    }
+    async markDappUserPoWCommitmentsStored(challenges) {
+        await this.tables?.powCaptcha.updateMany({ challenge: { $in: challenges } }, { $set: { stored: true } }, { upsert: false });
+    }
     async getBatchedDappUserCommitments() {
         const docs = await this.tables?.commitment.find({ batched: true }).lean();
         return docs ? docs.map((doc) => UserCommitmentSchema.parse(doc)) : [];
     }
     async removeProcessedDappUserSolutions(commitmentIds) {
-        return await this.tables?.usersolution.deleteMany({ processed: true, commitmentId: { $in: commitmentIds } });
+        return await this.tables?.usersolution.deleteMany({
+            processed: true,
+            commitmentId: { $in: commitmentIds },
+        });
     }
     async removeProcessedDappUserCommitments(commitmentIds) {
-        return await this.tables?.commitment.deleteMany({ processed: true, id: { $in: commitmentIds } });
+        return await this.tables?.commitment.deleteMany({
+            processed: true,
+            id: { $in: commitmentIds },
+        });
     }
     async storeDappUserPending(userAccount, requestHash, salt, deadlineTimestamp, requestedAtBlock) {
         if (!isHex(requestHash)) {
-            throw new ProsopoDBError('DATABASE.INVALID_HASH', {
-                context: { failedFuncName: this.storeDappUserPending.name, requestHash },
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+                context: {
+                    failedFuncName: this.storeDappUserPending.name,
+                    requestHash,
+                },
             });
         }
         const pendingRecord = {
@@ -416,24 +465,25 @@ export class ProsopoDatabase extends AsyncFactory {
     }
     async getDappUserPending(requestHash) {
         if (!isHex(requestHash)) {
-            throw new ProsopoEnvError('DATABASE.INVALID_HASH', {
+            throw new ProsopoEnvError("DATABASE.INVALID_HASH", {
                 context: { failedFuncName: this.getDappUserPending.name, requestHash },
             });
         }
-        const doc = await this.tables?.pending
-            .findOne({ requestHash: requestHash })
-            .lean();
+        const doc = await this.tables?.pending.findOne({ requestHash: requestHash }).lean();
         if (doc) {
             return doc;
         }
-        throw new ProsopoEnvError('DATABASE.PENDING_RECORD_NOT_FOUND', {
+        throw new ProsopoEnvError("DATABASE.PENDING_RECORD_NOT_FOUND", {
             context: { failedFuncName: this.getDappUserPending.name, requestHash },
         });
     }
     async updateDappUserPendingStatus(requestHash) {
         if (!isHex(requestHash)) {
-            throw new ProsopoEnvError('DATABASE.INVALID_HASH', {
-                context: { failedFuncName: this.updateDappUserPendingStatus.name, requestHash },
+            throw new ProsopoEnvError("DATABASE.INVALID_HASH", {
+                context: {
+                    failedFuncName: this.updateDappUserPendingStatus.name,
+                    requestHash,
+                },
             });
         }
         await this.tables?.pending.updateOne({ requestHash: requestHash }, {
@@ -453,15 +503,17 @@ export class ProsopoDatabase extends AsyncFactory {
         if (docs) {
             return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
         }
-        throw new ProsopoEnvError('DATABASE.CAPTCHA_GET_FAILED');
+        throw new ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED");
     }
     async getAllDappUserSolutions(captchaId) {
-        const cursor = this.tables?.usersolution?.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);
         }
-        throw new ProsopoEnvError('DATABASE.SOLUTION_GET_FAILED');
+        throw new ProsopoEnvError("DATABASE.SOLUTION_GET_FAILED");
     }
     async getDatasetIdWithSolvedCaptchasOfSizeN(solvedCaptchaCount) {
         const cursor = this.tables?.solution.aggregate([
@@ -470,7 +522,7 @@ export class ProsopoDatabase extends AsyncFactory {
             },
             {
                 $group: {
-                    _id: '$datasetId',
+                    _id: "$datasetId",
                     count: { $sum: 1 },
                 },
             },
@@ -484,15 +536,18 @@ export class ProsopoDatabase extends AsyncFactory {
             },
         ]);
         const docs = await cursor;
-        if (docs && docs.length) {
+        if (docs?.length) {
             return docs[0]._id;
         }
-        throw new ProsopoDBError('DATABASE.DATASET_WITH_SOLUTIONS_GET_FAILED');
+        throw new ProsopoDBError("DATABASE.DATASET_WITH_SOLUTIONS_GET_FAILED");
     }
     async getRandomSolvedCaptchasFromSingleDataset(datasetId, size) {
         if (!isHex(datasetId)) {
-            throw new ProsopoDBError('DATABASE.INVALID_HASH', {
-                context: { failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name, datasetId },
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+                context: {
+                    failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
+                    datasetId,
+                },
             });
         }
         const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
@@ -508,11 +563,15 @@ export class ProsopoDatabase extends AsyncFactory {
             },
         ]);
         const docs = await cursor;
-        if (docs && docs.length) {
+        if (docs?.length) {
             return docs;
         }
-        throw new ProsopoDBError('DATABASE.SOLUTION_GET_FAILED', {
-            context: { failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name, datasetId, size },
+        throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
+            context: {
+                failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
+                datasetId,
+                size,
+            },
         });
     }
     async getDappUserSolutionById(commitmentId) {
@@ -525,12 +584,14 @@ export class ProsopoDatabase extends AsyncFactory {
         if (doc) {
             return doc;
         }
-        throw new ProsopoDBError('DATABASE.SOLUTION_GET_FAILED', {
+        throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
             context: { failedFuncName: this.getCaptchaById.name, commitmentId },
         });
     }
     async getDappUserCommitmentById(commitmentId) {
-        const commitmentCursor = this.tables?.commitment?.findOne({ id: commitmentId }).lean();
+        const commitmentCursor = this.tables?.commitment
+            ?.findOne({ id: commitmentId })
+            .lean();
         const doc = await commitmentCursor;
         return doc ? UserCommitmentSchema.parse(doc) : undefined;
     }
@@ -547,7 +608,9 @@ export class ProsopoDatabase extends AsyncFactory {
                 .lean();
         }
         catch (err) {
-            throw new ProsopoDBError('DATABASE.SOLUTION_APPROVE_FAILED', { context: { error: err, commitmentId } });
+            throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
+                context: { error: err, commitmentId },
+            });
         }
     }
     async flagProcessedDappUserSolutions(captchaIds) {
@@ -557,7 +620,9 @@ export class ProsopoDatabase extends AsyncFactory {
                 .lean();
         }
         catch (err) {
-            throw new ProsopoDBError('DATABASE.SOLUTION_FLAG_FAILED', { context: { error: err, captchaIds } });
+            throw new ProsopoDBError("DATABASE.SOLUTION_FLAG_FAILED", {
+                context: { error: err, captchaIds },
+            });
         }
     }
     async flagProcessedDappUserCommitments(commitmentIds) {
@@ -568,7 +633,9 @@ export class ProsopoDatabase extends AsyncFactory {
                 .lean();
         }
         catch (err) {
-            throw new ProsopoDBError('DATABASE.COMMITMENT_FLAG_FAILED', { context: { error: err, commitmentIds } });
+            throw new ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", {
+                context: { error: err, commitmentIds },
+            });
         }
     }
     async flagBatchedDappUserCommitments(commitmentIds) {
@@ -579,12 +646,17 @@ export class ProsopoDatabase extends AsyncFactory {
                 .lean();
         }
         catch (err) {
-            throw new ProsopoDBError('DATABASE.COMMITMENT_FLAG_FAILED', { context: { error: err, commitmentIds } });
+            throw new ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", {
+                context: { error: err, commitmentIds },
+            });
         }
     }
     async getLastBatchCommitTime() {
         const cursor = this.tables?.scheduler
-            ?.findOne({ processName: ScheduledTaskNames.BatchCommitment, status: ScheduledTaskStatus.Completed })
+            ?.findOne({
+            processName: ScheduledTaskNames.BatchCommitment,
+            status: ScheduledTaskStatus.Completed,
+        })
             .sort({ timestamp: -1 });
         const doc = await cursor?.lean();
         if (doc) {
@@ -601,7 +673,7 @@ export class ProsopoDatabase extends AsyncFactory {
     async getLastScheduledTaskStatus(task, status) {
         const lookup = { processName: task };
         if (status) {
-            lookup['status'] = status;
+            lookup.status = status;
         }
         const cursor = await this.tables?.scheduler
             ?.findOne(lookup)