@prosopo/provider 2.1.4 → 2.1.6

package/dist/cjs/tasks/client/clientTasks.cjs

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const database = require("@prosopo/database");
+const types = require("@prosopo/types");
+class ClientTaskManager {
+  constructor(config, logger, db) {
+    this.config = config;
+    this.logger = logger;
+    this.providerDB = db;
+  }
+  /**
+   * @description Store commitments externally in the database
+   * @returns Promise<void>
+   */
+  async storeCommitmentsExternal() {
+    if (!this.config.mongoCaptchaUri) {
+      this.logger.info("Mongo env not set");
+      return;
+    }
+    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
+      types.ScheduledTaskNames.StoreCommitmentsExternal,
+      types.ScheduledTaskStatus.Completed
+    );
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      types.ScheduledTaskNames.StoreCommitmentsExternal,
+      types.ScheduledTaskStatus.Running
+    );
+    try {
+      let commitments = await this.providerDB.getUnstoredDappUserCommitments();
+      let powRecords = await this.providerDB.getUnstoredDappUserPoWCommitments();
+      if (lastTask) {
+        this.logger.info(
+          `Filtering records to only get updated records: ${JSON.stringify(lastTask)}`
+        );
+        this.logger.info(
+          "Last task ran at ",
+          new Date(lastTask.updated || 0),
+          "Task ID",
+          taskID
+        );
+        commitments = commitments.filter(
+          (commitment) => lastTask.updated && commitment.lastUpdatedTimestamp && (commitment.lastUpdatedTimestamp > lastTask.updated || !commitment.lastUpdatedTimestamp)
+        );
+        powRecords = powRecords.filter((commitment) => {
+          return lastTask.updated && commitment.lastUpdatedTimestamp && // either the update stamp is more recent than the last time this task ran or there is no update stamp,
+          // so it is a new record
+          (commitment.lastUpdatedTimestamp > lastTask.updated || !commitment.lastUpdatedTimestamp);
+        });
+      }
+      if (commitments.length || powRecords.length) {
+        this.logger.info(
+          `Storing ${commitments.length} commitments externally`
+        );
+        this.logger.info(
+          `Storing ${powRecords.length} pow challenges externally`
+        );
+        const captchaDB = new database.CaptchaDatabase(
+          this.config.mongoCaptchaUri,
+          void 0,
+          void 0,
+          this.logger
+        );
+        await captchaDB.saveCaptchas(commitments, powRecords);
+        await this.providerDB.markDappUserCommitmentsStored(
+          commitments.map((commitment) => commitment.id)
+        );
+        await this.providerDB.markDappUserPoWCommitmentsStored(
+          powRecords.map((powRecords2) => powRecords2.challenge)
+        );
+      }
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Completed,
+        {
+          data: {
+            commitments: commitments.map((c) => c.id),
+            powRecords: powRecords.map((pr) => pr.challenge)
+          }
+        }
+      );
+    } catch (e) {
+      this.logger.error(e);
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
+    }
+  }
+  /**
+   * @description Get a list of client accounts and their settings from the client database
+   * @returns Promise<void>
+   */
+  async getClientList() {
+    if (!this.config.mongoClientUri) {
+      this.logger.info("Mongo env not set");
+      return;
+    }
+    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
+      types.ScheduledTaskNames.GetClientList,
+      types.ScheduledTaskStatus.Completed
+    );
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      types.ScheduledTaskNames.GetClientList,
+      types.ScheduledTaskStatus.Running
+    );
+    try {
+      const clientDB = new database.ClientDatabase(
+        this.config.mongoClientUri,
+        void 0,
+        // expected to come from URI
+        void 0,
+        // expected to come from URI
+        this.logger
+      );
+      const updatedAtTimestamp = lastTask ? lastTask.updated || 0 : 0;
+      const newClientRecords = await clientDB.getUpdatedClients(updatedAtTimestamp);
+      if (newClientRecords) {
+        await this.providerDB.updateClientRecords(newClientRecords);
+      }
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Completed,
+        {
+          data: {
+            clientRecords: newClientRecords.map((c) => c.account)
+          }
+        }
+      );
+    } catch (e) {
+      this.logger.error(e);
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
+    }
+  }
+  async registerSiteKey(siteKey, settings) {
+    await this.providerDB.updateClientRecords([
+      {
+        account: siteKey,
+        settings
+      }
+    ]);
+  }
+}
+exports.ClientTaskManager = ClientTaskManager;

package/dist/cjs/tasks/dataset/datasetTasks.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const datasets = require("@prosopo/datasets");
+const datasetTasksUtils = require("./datasetTasksUtils.cjs");
+class DatasetManager {
+  constructor(config, logger, captchaConfig, db) {
+    this.config = config;
+    this.logger = logger;
+    this.captchaConfig = captchaConfig;
+    this.db = db;
+  }
+  /**
+   * @description Set the provider dataset from a file
+   *
+   * @param file JSON of the captcha dataset
+   */
+  async providerSetDatasetFromFile(file) {
+    const datasetRaw = datasets.parseCaptchaDataset(file);
+    return await this.providerSetDataset(datasetRaw);
+  }
+  async providerSetDataset(datasetRaw) {
+    const dataset = await datasetTasksUtils.providerValidateDataset(
+      datasetRaw,
+      this.captchaConfig.solved.count,
+      this.captchaConfig.unsolved.count
+    );
+    await this.db?.storeDataset(dataset);
+  }
+}
+exports.DatasetManager = DatasetManager;

package/dist/cjs/tasks/dataset/datasetTasksUtils.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("@prosopo/common");
+const datasets = require("@prosopo/datasets");
+const providerValidateDataset = async (datasetRaw, minSolvedCaptchas, minUnsolvedCaptchas) => {
+  if (datasetRaw.captchas.length < minSolvedCaptchas + minUnsolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.CAPTCHAS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const solutions = datasetRaw.captchas.map((captcha) => captcha.solution ? 1 : 0).reduce((partialSum, b) => partialSum + b, 0);
+  if (solutions < minSolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  if (solutions < minUnsolvedCaptchas) {
+    throw new common.ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const dataset = await datasets.buildDataset(datasetRaw);
+  if (!dataset.datasetId || !dataset.datasetContentId) {
+    throw new common.ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
+      context: {
+        failedFuncName: providerValidateDataset.name,
+        datasetId: dataset.datasetId,
+        datasetContentId: dataset.datasetContentId
+      }
+    });
+  }
+  return dataset;
+};
+exports.providerValidateDataset = providerValidateDataset;