@prosopo/database 2.1.1 → 2.1.3

package/dist/databases/provider.js

@@ -1,792 +0,0 @@
-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, 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 || (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,
-    },
-];
-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 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