@prosopo/database 2.1.4 → 2.1.6

package/dist/databases/provider.js

@@ -0,0 +1,823 @@
+import { isHex } from "@polkadot/util/is";
+import { ProsopoDBError, ProsopoEnvError } from "@prosopo/common";
+import { CaptchaStates, CaptchaStatus, DatasetWithIdsAndTreeSchema, } from "@prosopo/types";
+import { CaptchaRecordSchema, ClientRecordSchema, DatasetRecordSchema, PendingRecordSchema, PoWCaptchaRecordSchema, ScheduledTaskRecordSchema, ScheduledTaskSchema, SessionRecordSchema, SolutionRecordSchema, StoredStatusNames, UserCommitmentRecordSchema, UserCommitmentSchema, UserSolutionRecordSchema, } from "@prosopo/types-database";
+import { MongoDatabase } from "../base/mongo.js";
+var TableNames;
+(function (TableNames) {
+    TableNames["captcha"] = "captcha";
+    TableNames["dataset"] = "dataset";
+    TableNames["solution"] = "solution";
+    TableNames["commitment"] = "commitment";
+    TableNames["usersolution"] = "usersolution";
+    TableNames["pending"] = "pending";
+    TableNames["scheduler"] = "scheduler";
+    TableNames["powcaptcha"] = "powcaptcha";
+    TableNames["client"] = "client";
+    TableNames["session"] = "session";
+})(TableNames || (TableNames = {}));
+const PROVIDER_TABLES = [
+    {
+        collectionName: TableNames.captcha,
+        modelName: "Captcha",
+        schema: CaptchaRecordSchema,
+    },
+    {
+        collectionName: TableNames.powcaptcha,
+        modelName: "PowCaptcha",
+        schema: PoWCaptchaRecordSchema,
+    },
+    {
+        collectionName: TableNames.dataset,
+        modelName: "Dataset",
+        schema: DatasetRecordSchema,
+    },
+    {
+        collectionName: TableNames.solution,
+        modelName: "Solution",
+        schema: SolutionRecordSchema,
+    },
+    {
+        collectionName: TableNames.commitment,
+        modelName: "UserCommitment",
+        schema: UserCommitmentRecordSchema,
+    },
+    {
+        collectionName: TableNames.usersolution,
+        modelName: "UserSolution",
+        schema: UserSolutionRecordSchema,
+    },
+    {
+        collectionName: TableNames.pending,
+        modelName: "Pending",
+        schema: PendingRecordSchema,
+    },
+    {
+        collectionName: TableNames.scheduler,
+        modelName: "Scheduler",
+        schema: ScheduledTaskRecordSchema,
+    },
+    {
+        collectionName: TableNames.client,
+        modelName: "Client",
+        schema: ClientRecordSchema,
+    },
+    {
+        collectionName: TableNames.session,
+        modelName: "Session",
+        schema: SessionRecordSchema,
+    },
+];
+export class ProviderDatabase extends MongoDatabase {
+    constructor(url, dbname, authSource, logger) {
+        super(url, dbname, authSource, logger);
+        this.tables = {};
+        this.tables = {};
+    }
+    async connect() {
+        await super.connect();
+        this.loadTables();
+    }
+    loadTables() {
+        const tables = {};
+        PROVIDER_TABLES.map(({ collectionName, modelName, schema }) => {
+            if (this.connection) {
+                tables[collectionName] = this.connection.model(modelName, schema);
+            }
+        });
+        this.tables = tables;
+    }
+    getTables() {
+        if (!this.tables) {
+            throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
+                context: { failedFuncName: this.getTables.name },
+                logger: this.logger,
+            });
+        }
+        return this.tables;
+    }
+    async storeDataset(dataset) {
+        try {
+            this.logger.debug("Storing dataset in database");
+            const parsedDataset = DatasetWithIdsAndTreeSchema.parse(dataset);
+            const datasetDoc = {
+                datasetId: parsedDataset.datasetId,
+                datasetContentId: parsedDataset.datasetContentId,
+                format: parsedDataset.format,
+                contentTree: parsedDataset.contentTree,
+                solutionTree: parsedDataset.solutionTree,
+            };
+            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?.length,
+            }));
+            this.logger.debug("Inserting captcha records");
+            if (captchaDocs.length) {
+                await this.tables?.captcha.bulkWrite(captchaDocs.map((captchaDoc) => ({
+                    updateOne: {
+                        filter: { captchaId: captchaDoc.captchaId },
+                        update: { $set: captchaDoc },
+                        upsert: true,
+                    },
+                })));
+            }
+            const captchaSolutionDocs = parsedDataset.captchas
+                .filter(({ solution }) => solution?.length)
+                .map((captcha) => ({
+                captchaId: captcha.captchaId,
+                captchaContentId: captcha.captchaContentId,
+                solution: captcha.solution,
+                salt: captcha.salt,
+                datasetId: parsedDataset.datasetId,
+                datasetContentId: parsedDataset.datasetContentId,
+            }));
+            this.logger.debug("Inserting solution records");
+            if (captchaSolutionDocs.length) {
+                await this.tables?.solution.bulkWrite(captchaSolutionDocs.map((captchaSolutionDoc) => ({
+                    updateOne: {
+                        filter: { captchaId: captchaSolutionDoc.captchaId },
+                        update: { $set: captchaSolutionDoc },
+                        upsert: true,
+                    },
+                })));
+            }
+            this.logger.debug("Dataset stored in database");
+        }
+        catch (err) {
+            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();
+        return docs ? docs : [];
+    }
+    async getDataset(datasetId) {
+        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()) ||
+                [];
+            const solutions = (await this.tables?.solution
+                .find({ datasetId })
+                .lean()) || [];
+            const solutionsKeyed = {};
+            for (const solution of solutions) {
+                solutionsKeyed[solution.captchaId] = solution;
+            }
+            return {
+                datasetId,
+                datasetContentId,
+                format,
+                contentTree: contentTree || [],
+                solutionTree: solutionTree || [],
+                captchas: captchas.map((captchaDoc) => {
+                    const { captchaId, captchaContentId, items, target, salt, solved } = captchaDoc;
+                    const solution = solutionsKeyed[captchaId];
+                    return {
+                        captchaId,
+                        captchaContentId,
+                        solved: !!solved,
+                        salt,
+                        items,
+                        target,
+                        solution: solved && solution ? solution.solution : [],
+                    };
+                }),
+            };
+        }
+        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", {
+                context: { failedFuncName: this.getRandomCaptcha.name, datasetId },
+            });
+        }
+        const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
+        const cursor = this.tables?.captcha.aggregate([
+            { $match: { datasetId, solved } },
+            { $sample: { size: sampleSize } },
+            {
+                $project: {
+                    datasetId: 1,
+                    datasetContentId: 1,
+                    captchaId: 1,
+                    captchaContentId: 1,
+                    items: 1,
+                    target: 1,
+                },
+            },
+        ]);
+        const docs = await cursor;
+        if (docs?.length) {
+            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+        }
+        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 docs = await cursor;
+        if (docs?.length) {
+            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+        }
+        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", {
+                context: { failedFuncName: this.updateCaptcha.name, datasetId },
+            });
+        }
+        try {
+            await this.tables?.captcha.updateOne({ datasetId }, { $set: captcha }, { upsert: false });
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+                context: { failedFuncName: this.getDatasetDetails.name, error: err },
+            });
+        }
+    }
+    async removeCaptchas(captchaIds) {
+        await this.tables?.captcha.deleteMany({ captchaId: { $in: captchaIds } });
+    }
+    async getDatasetDetails(datasetId) {
+        if (!isHex(datasetId)) {
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+                context: { failedFuncName: this.getDatasetDetails.name, datasetId },
+            });
+        }
+        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,
+            },
+        });
+    }
+    async storeDappUserSolution(captchas, commit) {
+        const commitmentRecord = UserCommitmentSchema.parse({
+            ...commit,
+            lastUpdatedTimestamp: Date.now(),
+        });
+        if (captchas.length) {
+            await this.tables?.commitment.updateOne({
+                id: commit.id,
+            }, commitmentRecord, { upsert: true });
+            const ops = captchas.map((captcha) => ({
+                updateOne: {
+                    filter: { commitmentId: commit.id, captchaId: captcha.captchaId },
+                    update: {
+                        $set: {
+                            captchaId: captcha.captchaId,
+                            captchaContentId: captcha.captchaContentId,
+                            salt: captcha.salt,
+                            solution: captcha.solution,
+                            commitmentId: commit.id,
+                            processed: false,
+                        },
+                    },
+                    upsert: true,
+                },
+            }));
+            await this.tables?.usersolution.bulkWrite(ops);
+        }
+    }
+    async storePowCaptchaRecord(challenge, components, difficulty, providerSignature, ipAddress, headers, serverChecked = false, userSubmitted = false, storedStatus = StoredStatusNames.notStored, userSignature) {
+        const tables = this.getTables();
+        const powCaptchaRecord = {
+            challenge,
+            ...components,
+            ipAddress,
+            headers,
+            result: { status: CaptchaStatus.pending },
+            userSubmitted,
+            serverChecked,
+            difficulty,
+            providerSignature,
+            userSignature,
+            lastUpdatedTimestamp: Date.now(),
+        };
+        try {
+            await tables.powcaptcha.create(powCaptchaRecord);
+            this.logger.info("PowCaptcha record added successfully", {
+                challenge,
+                userSubmitted,
+                serverChecked,
+                storedStatus,
+            });
+        }
+        catch (error) {
+            this.logger.error("Failed to add PowCaptcha record", {
+                error,
+                challenge,
+                userSubmitted,
+                serverChecked,
+                storedStatus,
+            });
+            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+                context: {
+                    error,
+                    challenge,
+                    userSubmitted,
+                    serverChecked,
+                    storedStatus,
+                },
+                logger: this.logger,
+            });
+        }
+    }
+    async getPowCaptchaRecordByChallenge(challenge) {
+        if (!this.tables) {
+            throw new 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;
+            }
+            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", {
+                context: { error, challenge },
+                logger: this.logger,
+            });
+        }
+    }
+    async updatePowCaptchaRecord(challenge, result, serverChecked = false, userSubmitted = false, userSignature) {
+        const tables = this.getTables();
+        const timestamp = Date.now();
+        const update = {
+            result,
+            serverChecked,
+            userSubmitted,
+            userSignature,
+            lastUpdatedTimestamp: timestamp,
+        };
+        try {
+            const updateResult = await tables.powcaptcha.updateOne({ challenge }, {
+                $set: update,
+            });
+            if (updateResult.matchedCount === 0) {
+                this.logger.info("No PowCaptcha record found to update", {
+                    challenge,
+                    ...update,
+                });
+                throw new ProsopoDBError("DATABASE.CAPTCHA_GET_FAILED", {
+                    context: {
+                        challenge,
+                        ...update,
+                    },
+                    logger: this.logger,
+                });
+            }
+            this.logger.info("PowCaptcha record updated successfully", {
+                challenge,
+                ...update,
+            });
+        }
+        catch (error) {
+            this.logger.error("Failed to update PowCaptcha record", {
+                error,
+                challenge,
+                ...update,
+            });
+            throw new ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
+                context: {
+                    error,
+                    challenge,
+                    ...update,
+                },
+                logger: this.logger,
+            });
+        }
+    }
+    async getProcessedDappUserSolutions() {
+        const docs = await this.tables?.usersolution
+            .find({ processed: true })
+            .lean();
+        return docs || [];
+    }
+    async getProcessedDappUserCommitments() {
+        const docs = await this.tables?.commitment
+            .find({ processed: true })
+            .lean();
+        return docs || [];
+    }
+    async getCheckedDappUserCommitments() {
+        const docs = await this.tables?.commitment
+            .find({ [StoredStatusNames.serverChecked]: true })
+            .lean();
+        return docs || [];
+    }
+    async getUnstoredDappUserCommitments() {
+        const docs = await this.tables?.commitment
+            .find({
+            $or: [
+                { storedStatus: { $ne: StoredStatusNames.stored } },
+                { storedStatus: { $exists: false } },
+            ],
+        })
+            .lean();
+        return docs || [];
+    }
+    async markDappUserCommitmentsStored(commitmentIds) {
+        const updateDoc = {
+            storedAtTimestamp: Date.now(),
+        };
+        await this.tables?.commitment.updateMany({ id: { $in: commitmentIds } }, { $set: updateDoc }, { upsert: false });
+    }
+    async markDappUserCommitmentsChecked(commitmentIds) {
+        const updateDoc = {
+            [StoredStatusNames.serverChecked]: true,
+            lastUpdatedTimestamp: Date.now(),
+        };
+        await this.tables?.commitment.updateMany({ id: { $in: commitmentIds } }, { $set: updateDoc }, { upsert: false });
+    }
+    async getUnstoredDappUserPoWCommitments() {
+        const docs = await this.tables?.powcaptcha
+            .find({
+            $or: [
+                { storedStatus: { $ne: StoredStatusNames.stored } },
+                { storedStatus: { $exists: false } },
+            ],
+        })
+            .lean();
+        return docs || [];
+    }
+    async markDappUserPoWCommitmentsStored(challenges) {
+        const updateDoc = {
+            storedAtTimestamp: Date.now(),
+        };
+        await this.tables?.powcaptcha.updateMany({ challenge: { $in: challenges } }, { $set: updateDoc }, { upsert: false });
+    }
+    async markDappUserPoWCommitmentsChecked(challenges) {
+        const updateDoc = {
+            [StoredStatusNames.serverChecked]: true,
+            lastUpdatedTimestamp: Date.now(),
+        };
+        await this.tables?.powcaptcha.updateMany({ challenge: { $in: challenges } }, {
+            $set: updateDoc,
+        }, { upsert: false });
+    }
+    async storeSessionRecord(sessionRecord) {
+        try {
+            await this.tables.session.create(sessionRecord);
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.SESSION_STORE_FAILED", {
+                context: { error: err, sessionId: sessionRecord.sessionId },
+                logger: this.logger,
+            });
+        }
+    }
+    async checkAndRemoveSession(sessionId) {
+        try {
+            const session = await this.tables.session
+                .findOneAndDelete({ sessionId })
+                .lean();
+            return session || undefined;
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.SESSION_CHECK_REMOVE_FAILED", {
+                context: { error: err, sessionId },
+                logger: this.logger,
+            });
+        }
+    }
+    async removeProcessedDappUserSolutions(commitmentIds) {
+        return this.tables?.usersolution.deleteMany({
+            processed: true,
+            commitmentId: { $in: commitmentIds },
+        });
+    }
+    async removeProcessedDappUserCommitments(commitmentIds) {
+        return this.tables?.commitment.deleteMany({
+            processed: true,
+            id: { $in: commitmentIds },
+        });
+    }
+    async storeDappUserPending(userAccount, requestHash, salt, deadlineTimestamp, requestedAtTimestamp, ipAddress) {
+        if (!isHex(requestHash)) {
+            throw new ProsopoDBError("DATABASE.INVALID_HASH", {
+                context: {
+                    failedFuncName: this.storeDappUserPending.name,
+                    requestHash,
+                },
+            });
+        }
+        const pendingRecord = {
+            accountId: userAccount,
+            pending: true,
+            salt,
+            requestHash,
+            deadlineTimestamp,
+            requestedAtTimestamp,
+            ipAddress,
+        };
+        await this.tables?.pending.updateOne({ requestHash: requestHash }, { $set: pendingRecord }, { upsert: true });
+    }
+    async getDappUserPending(requestHash) {
+        if (!isHex(requestHash)) {
+            throw new ProsopoEnvError("DATABASE.INVALID_HASH", {
+                context: { failedFuncName: this.getDappUserPending.name, requestHash },
+            });
+        }
+        const doc = await this.tables?.pending
+            .findOne({ requestHash: requestHash })
+            .lean();
+        if (doc) {
+            return doc;
+        }
+        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,
+                },
+            });
+        }
+        await this.tables?.pending.updateOne({ requestHash: requestHash }, {
+            $set: {
+                [CaptchaStatus.pending]: false,
+            },
+        }, { upsert: true });
+    }
+    async getAllCaptchasByDatasetId(datasetId, state) {
+        const cursor = this.tables?.captcha
+            .find({
+            datasetId,
+            solved: state === CaptchaStates.Solved,
+        })
+            .lean();
+        const docs = await cursor;
+        if (docs) {
+            return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+        }
+        throw new ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED");
+    }
+    async getAllDappUserSolutions(captchaId) {
+        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");
+    }
+    async getDatasetIdWithSolvedCaptchasOfSizeN(solvedCaptchaCount) {
+        const cursor = this.tables?.solution.aggregate([
+            {
+                $match: {},
+            },
+            {
+                $group: {
+                    _id: "$datasetId",
+                    count: { $sum: 1 },
+                },
+            },
+            {
+                $match: {
+                    count: { $gte: solvedCaptchaCount },
+                },
+            },
+            {
+                $sample: { size: 1 },
+            },
+        ]);
+        const docs = await cursor;
+        if (docs?.length) {
+            return docs[0]._id;
+        }
+        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,
+                },
+            });
+        }
+        const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
+        const cursor = this.tables?.solution.aggregate([
+            { $match: { datasetId } },
+            { $sample: { size: sampleSize } },
+            {
+                $project: {
+                    captchaId: 1,
+                    captchaContentId: 1,
+                    solution: 1,
+                },
+            },
+        ]);
+        const docs = await cursor;
+        if (docs?.length) {
+            return docs;
+        }
+        throw new ProsopoDBError("DATABASE.SOLUTION_GET_FAILED", {
+            context: {
+                failedFuncName: this.getRandomSolvedCaptchasFromSingleDataset.name,
+                datasetId,
+                size,
+            },
+        });
+    }
+    async getDappUserSolutionById(commitmentId) {
+        const cursor = this.tables?.usersolution
+            ?.findOne({
+            commitmentId: commitmentId,
+        }, { projection: { _id: 0 } })
+            .lean();
+        const doc = await cursor;
+        if (doc) {
+            return doc;
+        }
+        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 doc = await commitmentCursor;
+        return doc ? doc : undefined;
+    }
+    async getDappUserCommitmentByAccount(userAccount, dappAccount) {
+        const docs = await this.tables?.commitment
+            ?.find({ userAccount, dappAccount }, { _id: 0 }, { sort: { _id: -1 } })
+            .lean();
+        return docs ? docs : [];
+    }
+    async approveDappUserCommitment(commitmentId) {
+        try {
+            const result = { status: CaptchaStatus.approved };
+            const updateDoc = {
+                result,
+                lastUpdatedTimestamp: Date.now(),
+            };
+            await this.tables?.commitment
+                ?.findOneAndUpdate({ id: commitmentId }, { $set: updateDoc }, { upsert: false })
+                .lean();
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
+                context: { error: err, commitmentId },
+            });
+        }
+    }
+    async disapproveDappUserCommitment(commitmentId, reason) {
+        try {
+            const updateDoc = {
+                result: { status: CaptchaStatus.disapproved, reason },
+                lastUpdatedTimestamp: Date.now(),
+            };
+            await this.tables?.commitment
+                ?.findOneAndUpdate({ id: commitmentId }, { $set: updateDoc }, { upsert: false })
+                .lean();
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.SOLUTION_APPROVE_FAILED", {
+                context: { error: err, commitmentId },
+            });
+        }
+    }
+    async flagProcessedDappUserSolutions(captchaIds) {
+        try {
+            await this.tables?.usersolution
+                ?.updateMany({ captchaId: { $in: captchaIds } }, { $set: { processed: true } }, { upsert: false })
+                .lean();
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.SOLUTION_FLAG_FAILED", {
+                context: { error: err, captchaIds },
+            });
+        }
+    }
+    async flagProcessedDappUserCommitments(commitmentIds) {
+        try {
+            const distinctCommitmentIds = [...new Set(commitmentIds)];
+            await this.tables?.commitment
+                ?.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { processed: true } }, { upsert: false })
+                .lean();
+        }
+        catch (err) {
+            throw new ProsopoDBError("DATABASE.COMMITMENT_FLAG_FAILED", {
+                context: { error: err, commitmentIds },
+            });
+        }
+    }
+    async getScheduledTaskStatus(taskId, status) {
+        const cursor = await this.tables?.scheduler
+            ?.findOne({ taskId: taskId, status: status })
+            .lean();
+        return cursor ? cursor : undefined;
+    }
+    async getLastScheduledTaskStatus(task, status) {
+        const lookup = { processName: task };
+        if (status) {
+            lookup.status = status;
+        }
+        const cursor = await this.tables?.scheduler
+            ?.findOne(lookup)
+            .sort({ datetime: -1 })
+            .limit(1)
+            .lean();
+        return cursor ? cursor : undefined;
+    }
+    async createScheduledTaskStatus(taskName, status) {
+        const now = new Date().getTime();
+        const doc = ScheduledTaskSchema.parse({
+            processName: taskName,
+            datetime: now,
+            status,
+        });
+        const taskRecord = await this.tables?.scheduler.create(doc);
+        return taskRecord._id;
+    }
+    async updateScheduledTaskStatus(taskId, status, result) {
+        const update = {
+            status,
+            updated: new Date().getTime(),
+            ...(result && { result }),
+        };
+        await this.tables?.scheduler.updateOne({ _id: taskId }, { $set: update }, {
+            upsert: false,
+        });
+    }
+    async updateClientRecords(clientRecords) {
+        const ops = clientRecords.map((record) => {
+            const clientRecord = {
+                account: record.account,
+                settings: record.settings,
+            };
+            return {
+                updateOne: {
+                    filter: { account: record.account },
+                    update: {
+                        $set: clientRecord,
+                    },
+                    upsert: true,
+                },
+            };
+        });
+        await this.tables?.client.bulkWrite(ops);
+    }
+    async getClientRecord(account) {
+        const doc = await this.tables?.client
+            .findOne({ account })
+            .lean();
+        return doc ? doc : undefined;
+    }
+}
+//# sourceMappingURL=provider.js.map