@prosopo/database 0.2.0 → 0.2.1

package/dist/cjs/databases/index.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const mongo = require("./mongo.cjs");
+const mongoMemory = require("./mongoMemory.cjs");
+const Databases = {
+  [types.DatabaseTypes.Values.mongo]: mongo.ProsopoDatabase,
+  [types.DatabaseTypes.Values.mongoMemory]: mongoMemory.MongoMemoryDatabase
+};
+exports.Databases = Databases;

package/dist/cjs/databases/mongo.cjs

@@ -0,0 +1,614 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("@prosopo/types");
+const common = require("@prosopo/common");
+const typesDatabase = require("@prosopo/types-database");
+const mongodb = require("mongodb");
+const util = require("@polkadot/util");
+const mongoose = require("mongoose");
+mongoose.set("strictQuery", false);
+const DEFAULT_ENDPOINT = "mongodb://127.0.0.1:27017";
+class ProsopoDatabase extends common.AsyncFactory {
+  constructor() {
+    super();
+    this.url = "";
+    this.dbname = "";
+    this.logger = common.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;
+  }
+  /**
+   * @description Connect to the database and set the various tables
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      if (this.connection) {
+        resolve();
+      }
+      this.logger.info(`Mongo url: ${this.url.replace(/\w+:\w+/, "<Credentials>")}`);
+      this.connection = mongoose.createConnection(this.url, {
+        dbName: this.dbname,
+        serverApi: mongodb.ServerApiVersion.v1
+      });
+      this.tables = {
+        captcha: this.connection.models.Captcha || this.connection.model("Captcha", typesDatabase.CaptchaRecordSchema),
+        dataset: this.connection.models.Dataset || this.connection.model("Dataset", typesDatabase.DatasetRecordSchema),
+        solution: this.connection.models.Solution || this.connection.model("Solution", typesDatabase.SolutionRecordSchema),
+        commitment: this.connection.models.UserCommitment || this.connection.model("UserCommitment", typesDatabase.UserCommitmentRecordSchema),
+        usersolution: this.connection.models.UserSolution || this.connection.model("UserSolution", typesDatabase.UserSolutionRecordSchema),
+        pending: this.connection.models.Pending || this.connection.model("Pending", typesDatabase.PendingRecordSchema),
+        scheduler: this.connection.models.Scheduler || this.connection.model("Scheduler", typesDatabase.ScheduledTaskRecordSchema)
+      };
+      this.connection.once("open", resolve).on("error", (e) => {
+        this.logger.warn(`mongoose connection error`);
+        if (e.message.code === "ETIMEDOUT") {
+          this.logger.error(e);
+          mongoose.connect(this.url);
+        }
+        this.logger.error(e);
+        reject(new common.ProsopoEnvError(e, "DATABASE.CONNECT_ERROR", {}, this.url));
+      });
+    });
+  }
+  /** Close connection to the database */
+  async close() {
+    this.logger.info(`Closing connection to ${this.url}`);
+    await new Promise(async (resolve, reject) => {
+      mongoose.connection.close().then(() => {
+        this.logger.info(`Connection to ${this.url} closed`);
+        resolve();
+      }).catch(reject);
+    });
+  }
+  /**
+   * @description Load a dataset to the database
+   * @param {Dataset}  dataset
+   */
+  async storeDataset(dataset) {
+    var _a, _b, _c;
+    try {
+      this.logger.info(`Storing dataset in database`);
+      const parsedDataset = types.DatasetWithIdsAndTreeSchema.parse(dataset);
+      const datasetDoc = {
+        datasetId: parsedDataset.datasetId,
+        datasetContentId: parsedDataset.datasetContentId,
+        format: parsedDataset.format,
+        contentTree: parsedDataset.contentTree,
+        solutionTree: parsedDataset.solutionTree
+      };
+      await ((_a = this.tables) == null ? void 0 : _a.dataset.updateOne(
+        { datasetId: parsedDataset.datasetId },
+        { $set: datasetDoc },
+        { upsert: true }
+      ));
+      this.logger.info("parsedDataset.captchas", parsedDataset.captchas);
+      const captchaDocs = parsedDataset.captchas.map(({ solution, ...captcha }, index) => ({
+        ...captcha,
+        datasetId: parsedDataset.datasetId,
+        datasetContentId: parsedDataset.datasetContentId,
+        index,
+        solved: !!(solution == null ? void 0 : solution.length)
+      }));
+      this.logger.info(`Inserting captcha records`);
+      if (captchaDocs.length) {
+        await ((_b = this.tables) == null ? void 0 : _b.captcha.bulkWrite(
+          captchaDocs.map((captchaDoc) => ({
+            updateOne: {
+              filter: { captchaId: captchaDoc.captchaId },
+              update: { $set: captchaDoc },
+              upsert: true
+            }
+          }))
+        ));
+      }
+      const captchaSolutionDocs = parsedDataset.captchas.filter(({ solution }) => solution == null ? void 0 : solution.length).map((captcha) => ({
+        captchaId: captcha.captchaId,
+        captchaContentId: captcha.captchaContentId,
+        solution: captcha.solution,
+        salt: captcha.salt,
+        datasetId: parsedDataset.datasetId,
+        datasetContentId: parsedDataset.datasetContentId
+      }));
+      this.logger.info(`Inserting solution records`);
+      if (captchaSolutionDocs.length) {
+        await ((_c = this.tables) == null ? void 0 : _c.solution.bulkWrite(
+          captchaSolutionDocs.map((captchaSolutionDoc) => ({
+            updateOne: {
+              filter: { captchaId: captchaSolutionDoc.captchaId },
+              update: { $set: captchaSolutionDoc },
+              upsert: true
+            }
+          }))
+        ));
+      }
+      this.logger.info(`Dataset stored in database`);
+    } catch (err) {
+      throw new common.ProsopoEnvError(err, "DATABASE.DATASET_LOAD_FAILED");
+    }
+  }
+  /** @description Get a dataset from the database
+   * @param {string} datasetId
+   */
+  async getDataset(datasetId) {
+    var _a, _b, _c;
+    const datasetDoc = await ((_a = this.tables) == null ? void 0 : _a.dataset.findOne({ datasetId }).lean());
+    if (datasetDoc) {
+      const { datasetContentId, format, contentTree, solutionTree } = datasetDoc;
+      const captchas = await ((_b = this.tables) == null ? void 0 : _b.captcha.find({ datasetId }).lean()) || [];
+      const solutions = await ((_c = this.tables) == null ? void 0 : _c.solution.find({ datasetId }).lean()) || [];
+      const 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 common.ProsopoEnvError("DATABASE.DATASET_GET_FAILED", void 0, {}, datasetId);
+  }
+  /**
+   * @description Get random captchas that are solved or not solved
+   * @param {boolean}  solved    `true` when captcha is solved
+   * @param {string}   datasetId  the id of the data set
+   * @param {number}   size       the number of records to be returned
+   */
+  async getRandomCaptcha(solved, datasetId, size) {
+    var _a;
+    if (!util.isHex(datasetId)) {
+      throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", this.getRandomCaptcha.name, {}, datasetId);
+    }
+    const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
+    const cursor = (_a = this.tables) == null ? void 0 : _a.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 && docs.length) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+    }
+    throw new common.ProsopoEnvError(
+      "DATABASE.CAPTCHA_GET_FAILED",
+      this.getRandomCaptcha.name,
+      {},
+      {
+        solved,
+        datasetId,
+        size
+      }
+    );
+  }
+  /**
+   * @description Get captchas by id
+   * @param {string[]} captchaId
+   */
+  async getCaptchaById(captchaId) {
+    var _a;
+    const cursor = (_a = this.tables) == null ? void 0 : _a.captcha.find({ captchaId: { $in: captchaId } }).lean();
+    const docs = await cursor;
+    if (docs && docs.length) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+    }
+    throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED", this.getCaptchaById.name, {}, captchaId);
+  }
+  /**
+   * @description Update a captcha
+   * @param {Captcha}  captcha
+   * @param {string}   datasetId  the id of the data set
+   */
+  async updateCaptcha(captcha, datasetId) {
+    var _a;
+    if (!util.isHex(datasetId)) {
+      throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", this.updateCaptcha.name, {}, datasetId);
+    }
+    try {
+      await ((_a = this.tables) == null ? void 0 : _a.captcha.updateOne({ datasetId }, { $set: captcha }, { upsert: false }));
+    } catch (err) {
+      throw new common.ProsopoEnvError(err);
+    }
+  }
+  /**
+   * @description Remove captchas
+   */
+  async removeCaptchas(captchaIds) {
+    var _a;
+    await ((_a = this.tables) == null ? void 0 : _a.captcha.deleteMany({ captchaId: { $in: captchaIds } }));
+  }
+  /**
+   * @description Get a dataset by Id
+   */
+  async getDatasetDetails(datasetId) {
+    var _a;
+    if (!util.isHex(datasetId)) {
+      throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", this.getDatasetDetails.name, {}, datasetId);
+    }
+    const doc = await ((_a = this.tables) == null ? void 0 : _a.dataset.findOne({ datasetId }).lean());
+    if (doc) {
+      return doc;
+    }
+    throw new common.ProsopoEnvError("DATABASE.DATASET_GET_FAILED", this.getDatasetDetails.name, {}, datasetId);
+  }
+  /**
+   * @description Store a Dapp User's captcha solution commitment
+   */
+  async storeDappUserSolution(captchas, commit) {
+    var _a, _b;
+    const commitmentRecord = typesDatabase.UserCommitmentSchema.parse(commit);
+    if (captchas.length) {
+      await ((_a = this.tables) == null ? void 0 : _a.commitment.updateOne(
+        {
+          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 ((_b = this.tables) == null ? void 0 : _b.usersolution.bulkWrite(ops));
+    }
+  }
+  /** @description Get processed Dapp User captcha solutions from the user solution table
+   */
+  async getProcessedDappUserSolutions() {
+    var _a;
+    const docs = await ((_a = this.tables) == null ? void 0 : _a.usersolution.find({ processed: true }).lean());
+    return docs ? docs.map((doc) => typesDatabase.UserSolutionSchema.parse(doc)) : [];
+  }
+  /** @description Get processed Dapp User captcha commitments from the commitments table
+   */
+  async getProcessedDappUserCommitments() {
+    var _a;
+    const docs = await ((_a = this.tables) == null ? void 0 : _a.commitment.find({ processed: true }).lean());
+    return docs ? docs.map((doc) => typesDatabase.UserCommitmentSchema.parse(doc)) : [];
+  }
+  /** @description Get Dapp User captcha commitments from the commitments table that have not been batched on-chain
+   */
+  async getUnbatchedDappUserCommitments() {
+    var _a;
+    const docs = await ((_a = this.tables) == null ? void 0 : _a.commitment.find({ batched: false }).lean());
+    return docs ? docs.map((doc) => typesDatabase.UserCommitmentSchema.parse(doc)) : [];
+  }
+  /** @description Get Dapp User captcha commitments from the commitments table that have been batched on-chain
+   */
+  async getBatchedDappUserCommitments() {
+    var _a;
+    const docs = await ((_a = this.tables) == null ? void 0 : _a.commitment.find({ batched: true }).lean());
+    return docs ? docs.map((doc) => typesDatabase.UserCommitmentSchema.parse(doc)) : [];
+  }
+  /** @description Remove processed Dapp User captcha solutions from the user solution table
+   */
+  async removeProcessedDappUserSolutions(commitmentIds) {
+    var _a;
+    return await ((_a = this.tables) == null ? void 0 : _a.usersolution.deleteMany({ processed: true, commitmentId: { $in: commitmentIds } }));
+  }
+  /** @description Remove processed Dapp User captcha commitments from the user commitments table
+   */
+  async removeProcessedDappUserCommitments(commitmentIds) {
+    var _a;
+    return await ((_a = this.tables) == null ? void 0 : _a.commitment.deleteMany({ processed: true, id: { $in: commitmentIds } }));
+  }
+  /**
+   * @description Store a Dapp User's pending record
+   */
+  async storeDappUserPending(userAccount, requestHash, salt, deadlineTimestamp, requestedAtBlock) {
+    var _a;
+    if (!util.isHex(requestHash)) {
+      throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", this.storeDappUserPending.name, {}, requestHash);
+    }
+    const pendingRecord = {
+      accountId: userAccount,
+      pending: true,
+      salt,
+      requestHash,
+      deadlineTimestamp,
+      requestedAtBlock
+    };
+    await ((_a = this.tables) == null ? void 0 : _a.pending.updateOne({ requestHash }, { $set: pendingRecord }, { upsert: true }));
+  }
+  /**
+   * @description Get a Dapp user's pending record
+   */
+  async getDappUserPending(requestHash) {
+    var _a;
+    if (!util.isHex(requestHash)) {
+      throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", this.getDappUserPending.name, {}, requestHash);
+    }
+    const doc = await ((_a = this.tables) == null ? void 0 : _a.pending.findOne({ requestHash }).lean());
+    if (doc) {
+      return doc;
+    }
+    throw new common.ProsopoEnvError("DATABASE.PENDING_RECORD_NOT_FOUND", this.getDappUserPending.name);
+  }
+  /**
+   * @description Update a Dapp User's pending record
+   */
+  async updateDappUserPendingStatus(userAccount, requestHash, approve) {
+    var _a;
+    if (!util.isHex(requestHash)) {
+      throw new common.ProsopoEnvError("DATABASE.INVALID_HASH", this.updateDappUserPendingStatus.name, {}, requestHash);
+    }
+    await ((_a = this.tables) == null ? void 0 : _a.pending.updateOne(
+      { requestHash },
+      {
+        $set: {
+          accountId: userAccount,
+          pending: false,
+          approved: approve,
+          requestHash
+        }
+      },
+      { upsert: true }
+    ));
+  }
+  /**
+   * @description Get all unsolved captchas
+   */
+  async getAllCaptchasByDatasetId(datasetId, state) {
+    var _a;
+    const cursor = (_a = this.tables) == null ? void 0 : _a.captcha.find({
+      datasetId,
+      solved: state === types.CaptchaStates.Solved
+    }).lean();
+    const docs = await cursor;
+    if (docs) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+    }
+    throw new common.ProsopoEnvError("DATABASE.CAPTCHA_GET_FAILED");
+  }
+  /**
+   * @description Get all dapp user solutions by captchaIds
+   */
+  async getAllDappUserSolutions(captchaId) {
+    var _a, _b;
+    const cursor = (_b = (_a = this.tables) == null ? void 0 : _a.usersolution) == null ? void 0 : _b.find({ captchaId: { $in: captchaId } }).lean();
+    const docs = await cursor;
+    if (docs) {
+      return docs.map(({ _id, ...keepAttrs }) => keepAttrs);
+    }
+    throw new common.ProsopoEnvError("DATABASE.SOLUTION_GET_FAILED");
+  }
+  async getDatasetIdWithSolvedCaptchasOfSizeN(solvedCaptchaCount) {
+    var _a;
+    const cursor = (_a = this.tables) == null ? void 0 : _a.solution.aggregate([
+      {
+        $match: {}
+      },
+      {
+        $group: {
+          _id: "$datasetId",
+          count: { $sum: 1 }
+        }
+      },
+      {
+        $match: {
+          count: { $gte: solvedCaptchaCount }
+        }
+      },
+      {
+        $sample: { size: 1 }
+      }
+    ]);
+    const docs = await cursor;
+    if (docs && docs.length) {
+      return docs[0]._id;
+    }
+    throw new common.ProsopoEnvError("DATABASE.DATASET_WITH_SOLUTIONS_GET_FAILED");
+  }
+  async getRandomSolvedCaptchasFromSingleDataset(datasetId, size) {
+    var _a;
+    if (!util.isHex(datasetId)) {
+      throw new common.ProsopoEnvError(
+        "DATABASE.INVALID_HASH",
+        this.getRandomSolvedCaptchasFromSingleDataset.name,
+        {},
+        datasetId
+      );
+    }
+    const sampleSize = size ? Math.abs(Math.trunc(size)) : 1;
+    const cursor = (_a = this.tables) == null ? void 0 : _a.solution.aggregate([
+      { $match: { datasetId } },
+      { $sample: { size: sampleSize } },
+      {
+        $project: {
+          captchaId: 1,
+          captchaContentId: 1,
+          solution: 1
+        }
+      }
+    ]);
+    const docs = await cursor;
+    if (docs && docs.length) {
+      return docs;
+    }
+    throw new common.ProsopoEnvError("DATABASE.SOLUTION_GET_FAILED");
+  }
+  /**
+   * @description Get dapp user solution by ID
+   * @param {string[]} commitmentId
+   */
+  async getDappUserSolutionById(commitmentId) {
+    var _a, _b;
+    const cursor = (_b = (_a = this.tables) == null ? void 0 : _a.usersolution) == null ? void 0 : _b.findOne(
+      {
+        commitmentId
+      },
+      { projection: { _id: 0 } }
+    ).lean();
+    const doc = await cursor;
+    if (doc) {
+      return doc;
+    }
+    throw new common.ProsopoEnvError("DATABASE.SOLUTION_GET_FAILED", this.getCaptchaById.name, {}, commitmentId);
+  }
+  /**
+   * @description Get dapp user commitment by user account
+   * @param commitmentId
+   */
+  async getDappUserCommitmentById(commitmentId) {
+    var _a, _b;
+    const commitmentCursor = (_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.findOne({ id: commitmentId }).lean();
+    const doc = await commitmentCursor;
+    return doc ? typesDatabase.UserCommitmentSchema.parse(doc) : void 0;
+  }
+  /**
+   * @description Get dapp user commitment by user account
+   * @param {string[]} userAccount
+   */
+  async getDappUserCommitmentByAccount(userAccount) {
+    var _a, _b;
+    const docs = await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.find({ userAccount }).lean());
+    return docs ? docs : [];
+  }
+  /**
+   * @description Approve a dapp user's solution
+   * @param {string[]} commitmentId
+   */
+  async approveDappUserCommitment(commitmentId) {
+    var _a, _b;
+    try {
+      await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.findOneAndUpdate(
+        { id: commitmentId },
+        { $set: { status: types.CaptchaStatus.approved } },
+        { upsert: false }
+      ).lean());
+    } catch (err) {
+      throw new common.ProsopoEnvError(err, "DATABASE.SOLUTION_APPROVE_FAILED", {}, commitmentId);
+    }
+  }
+  /**
+   * @description Flag a dapp user's solutions as used by calculated solution
+   * @param {string[]} captchaIds
+   */
+  async flagProcessedDappUserSolutions(captchaIds) {
+    var _a, _b;
+    try {
+      await ((_b = (_a = this.tables) == null ? void 0 : _a.usersolution) == null ? void 0 : _b.updateMany({ captchaId: { $in: captchaIds } }, { $set: { processed: true } }, { upsert: false }).lean());
+    } catch (err) {
+      throw new common.ProsopoEnvError(err, "DATABASE.SOLUTION_FLAG_FAILED", {}, captchaIds);
+    }
+  }
+  /**
+   * @description Flag dapp users' commitments as used by calculated solution
+   * @param {string[]} commitmentIds
+   */
+  async flagProcessedDappUserCommitments(commitmentIds) {
+    var _a, _b;
+    try {
+      const distinctCommitmentIds = [...new Set(commitmentIds)];
+      await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { processed: true } }, { upsert: false }).lean());
+    } catch (err) {
+      throw new common.ProsopoEnvError(err, "DATABASE.COMMITMENT_FLAG_FAILED", {}, commitmentIds);
+    }
+  }
+  /**
+   * @description Flag dapp users' commitments as used by calculated solution
+   * @param {string[]} commitmentIds
+   */
+  async flagBatchedDappUserCommitments(commitmentIds) {
+    var _a, _b;
+    try {
+      const distinctCommitmentIds = [...new Set(commitmentIds)];
+      await ((_b = (_a = this.tables) == null ? void 0 : _a.commitment) == null ? void 0 : _b.updateMany({ id: { $in: distinctCommitmentIds } }, { $set: { batched: true } }, { upsert: false }).lean());
+    } catch (err) {
+      throw new common.ProsopoEnvError(err, "DATABASE.COMMITMENT_FLAG_FAILED", {}, commitmentIds);
+    }
+  }
+  /**
+   * @description Get the last batch commit time or return 0 if none
+   */
+  async getLastBatchCommitTime() {
+    var _a, _b;
+    const cursor = (_b = (_a = this.tables) == null ? void 0 : _a.scheduler) == null ? void 0 : _b.findOne({ processName: types.ScheduledTaskNames.BatchCommitment, status: types.ScheduledTaskStatus.Completed }).sort({ timestamp: -1 });
+    const doc = await (cursor == null ? void 0 : cursor.lean());
+    if (doc) {
+      return doc.datetime;
+    }
+    return /* @__PURE__ */ new Date(0);
+  }
+  /**
+   * @description Get a scheduled task status record by task ID and status
+   */
+  async getScheduledTaskStatus(taskId, status) {
+    var _a, _b;
+    const cursor = await ((_b = (_a = this.tables) == null ? void 0 : _a.scheduler) == null ? void 0 : _b.findOne({ taskId, status }).lean());
+    return cursor ? cursor : void 0;
+  }
+  /**
+   * @description Get the most recent scheduled task status record for a given task
+   */
+  async getLastScheduledTaskStatus(task, status) {
+    var _a, _b;
+    const lookup = { processName: task };
+    if (status) {
+      lookup["status"] = status;
+    }
+    const cursor = await ((_b = (_a = this.tables) == null ? void 0 : _a.scheduler) == null ? void 0 : _b.findOne(lookup).sort({ datetime: -1 }).lean());
+    return cursor ? cursor : void 0;
+  }
+  /**
+   * @description Store the status of a scheduled task and an optional result
+   */
+  async storeScheduledTaskStatus(taskId, task, status, result) {
+    var _a;
+    const now = /* @__PURE__ */ new Date();
+    const doc = typesDatabase.ScheduledTaskSchema.parse({
+      taskId,
+      processName: task,
+      datetime: now,
+      status,
+      ...result && { result }
+    });
+    await ((_a = this.tables) == null ? void 0 : _a.scheduler.create(doc));
+  }
+}
+exports.ProsopoDatabase = ProsopoDatabase;

package/dist/cjs/databases/mongoMemory.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mongo = require("./mongo.cjs");
+const mongodbMemoryServer = require("mongodb-memory-server");
+class MongoMemoryDatabase extends mongo.ProsopoDatabase {
+  async init(url, dbname, logger, authSource) {
+    const mongod = await mongodbMemoryServer.MongoMemoryServer.create();
+    const mongoMemoryURL = mongod.getUri();
+    await super.init(mongoMemoryURL, dbname, logger, authSource);
+    return this;
+  }
+}
+exports.MongoMemoryDatabase = MongoMemoryDatabase;

package/dist/cjs/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./databases/index.cjs");
+exports.Databases = index.Databases;

package/package.json

@@ -1,12 +1,19 @@
 {
     "name": "@prosopo/database",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "Prosopo database plugins for provider",
     "main": "dist/index.js",
     "type": "module",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "require": "./dist/cjs/index.cjs"
+        }
+    },
     "scripts": {
         "clean": "tsc --build --clean",
-        "build": "tsc --build --verbose",
+        "build": "tsc --build --verbose tsconfig.json",
+        "build:cjs": "npx vite --config vite.cjs.config.ts build",
         "lint": "npx eslint .",
         "lint:fix": "npx eslint . --fix --config ../../.eslintrc.js"
     },
@@ -21,9 +28,9 @@
     },
     "homepage": "https://github.com/prosopo/captcha#readme",
     "dependencies": {
-        "@prosopo/common": "0.2.0",
-        "@prosopo/types": "0.2.0",
-        "@prosopo/types-database": "0.2.0",
+        "@prosopo/common": "0.2.1",
+        "@prosopo/types": "0.2.1",
+        "@prosopo/types-database": "0.2.1",
         "mongodb": "5.8.0",
         "mongodb-memory-server": "^8.7.2",
         "mongoose": "^7.3.3",

package/vite.cjs.config.ts

@@ -0,0 +1,6 @@
+import { ViteCommonJSConfig } from '@prosopo/config'
+import path from 'path'
+
+export default function () {
+    return ViteCommonJSConfig('database', path.resolve('./tsconfig.cjs.json'))
+}