@prosopo/database 2.1.6 → 2.1.8

package/dist/databases/mongo.js

@@ -1,682 +0,0 @@
-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 { isHex } from "@polkadot/util/is";
-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.logger = getLoggerDefault();
-    }
-    async init(url, dbname, logger, authSource) {
-        const baseEndpoint = url || DEFAULT_ENDPOINT;
-        const parsedUrl = new URL(baseEndpoint);
-        parsedUrl.pathname = dbname;
-        if (authSource) {
-            parsedUrl.searchParams.set("authSource", authSource);
-        }
-        this.url = parsedUrl.toString();
-        this.dbname = dbname;
-        this.logger = logger;
-        return this;
-    }
-    getTables() {
-        if (!this.tables) {
-            throw new ProsopoDBError("DATABASE.TABLES_UNDEFINED", {
-                context: { failedFuncName: this.getTables.name },
-                logger: this.logger,
-            });
-        }
-        return this.tables;
-    }
-    getConnection() {
-        if (!this.connection) {
-            throw new ProsopoDBError("DATABASE.CONNECTION_UNDEFINED", {
-                context: { failedFuncName: this.getConnection.name },
-                logger: this.logger,
-            });
-        }
-        return this.connection;
-    }
-    async connect() {
-        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", () => {
-                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}`);
-                resolve(connection);
-            });
-            connection.on("disconnected", () => {
-                this.logger.info(`Database disconnected from ${this.url}`);
-            });
-            connection.on("reconnected", () => {
-                this.logger.info(`Database reconnected to ${this.url}`);
-                resolve(connection);
-            });
-            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`);
-                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),
-        };
-    }
-    async close() {
-        this.logger.debug(`Closing connection to ${this.url}`);
-        await this.connection?.close();
-    }
-    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);
-        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, checked) {
-        const tables = this.getTables();
-        const powCaptchaRecord = {
-            challenge,
-            checked,
-        };
-        try {
-            await 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 ProsopoDBError("DATABASE.CAPTCHA_UPDATE_FAILED", {
-                context: { error, challenge, checked },
-                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, checked) {
-        const tables = this.getTables();
-        try {
-            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", {
-                    context: { challenge, checked },
-                    logger: this.logger,
-                });
-            }
-            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", {
-                context: { error, challenge, checked },
-                logger: this.logger,
-            });
-        }
-    }
-    async getProcessedDappUserSolutions() {
-        const docs = await this.tables?.usersolution
-            .find({ processed: true })
-            .lean();
-        return docs ? docs.map((doc) => UserSolutionSchema.parse(doc)) : [];
-    }
-    async getProcessedDappUserCommitments() {
-        const docs = await this.tables?.commitment.find({ processed: true }).lean();
-        return docs ? docs.map((doc) => UserCommitmentSchema.parse(doc)) : [];
-    }
-    async getUnbatchedDappUserCommitments() {
-        const docs = await this.tables?.commitment.find({ batched: false }).lean();
-        return docs ? docs.map((doc) => UserCommitmentSchema.parse(doc)) : [];
-    }
-    async getUnstoredDappUserCommitments() {
-        const docs = await this.tables?.commitment
-            .find({
-            $or: [{ stored: false }, { stored: { $exists: false } }],
-        })
-            .lean();
-        return docs ? docs.map((doc) => UserCommitmentSchema.parse(doc)) : [];
-    }
-    async markDappUserCommitmentsStored(commitmentIds) {
-        await this.tables?.commitment.updateMany({ id: { $in: commitmentIds } }, { $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 },
-        });
-    }
-    async removeProcessedDappUserCommitments(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,
-                },
-            });
-        }
-        const pendingRecord = {
-            accountId: userAccount,
-            pending: true,
-            salt,
-            requestHash,
-            deadlineTimestamp,
-            requestedAtBlock,
-        };
-        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: {
-                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 ? UserCommitmentSchema.parse(doc) : undefined;
-    }
-    async getDappUserCommitmentByAccount(userAccount) {
-        const docs = await this.tables?.commitment
-            ?.find({ userAccount }, { _id: 0 }, { sort: { _id: -1 } })
-            .lean();
-        return docs ? docs : [];
-    }
-    async approveDappUserCommitment(commitmentId) {
-        try {
-            await this.tables?.commitment
-                ?.findOneAndUpdate({ id: commitmentId }, { $set: { status: CaptchaStatus.approved } }, { 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 flagBatchedDappUserCommitments(commitmentIds) {
-        try {
-            const distinctCommitmentIds = [...new Set(commitmentIds)];
-            await this.tables?.commitment
-                ?.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { batched: true } }, { upsert: false })
-                .lean();
-        }
-        catch (err) {
-            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,
-        })
-            .sort({ timestamp: -1 });
-        const doc = await cursor?.lean();
-        if (doc) {
-            return doc.datetime;
-        }
-        return new Date(0);
-    }
-    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 })
-            .lean();
-        return cursor ? cursor : undefined;
-    }
-    async storeScheduledTaskStatus(taskId, task, status, result) {
-        const now = new Date();
-        const doc = ScheduledTaskSchema.parse({
-            taskId,
-            processName: task,
-            datetime: now,
-            status,
-            ...(result && { result }),
-        });
-        await this.tables?.scheduler.create(doc);
-    }
-}
-//# sourceMappingURL=mongo.js.map