@prosopo/provider 3.2.0 → 3.2.1

package/dist/tasks/client/clientTasks.js

@@ -1,228 +1,289 @@
 import { createPrivateKey } from "node:crypto";
 import { ProsopoApiError } from "@prosopo/common";
 import { CaptchaDatabase, ClientDatabase } from "@prosopo/database";
-import { ScheduledTaskNames, ScheduledTaskStatus, } from "@prosopo/types";
+import { ScheduledTaskNames, ScheduledTaskStatus } from "@prosopo/types";
 import { parseUrl } from "@prosopo/util";
 import { validateSiteKey } from "../../api/validateAddress.js";
 const isValidPrivateKey = (privateKeyString) => {
-    const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
-    try {
-        createPrivateKey({
-            key: privateKey,
-            format: "pem",
-            type: "pkcs8",
-        });
-        return true;
+  const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
+  try {
+    createPrivateKey({
+      key: privateKey,
+      format: "pem",
+      type: "pkcs8"
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+class ClientTaskManager {
+  constructor(config, logger, db) {
+    this.config = config;
+    this.logger = logger;
+    this.providerDB = db;
+  }
+  /**
+   * @description Get the captcha database connection or create a new one
+   * @returns CaptchaDatabase
+   */
+  getCaptchaDB(mongoCaptchaUri) {
+    if (this.captchaDB) {
+      return this.captchaDB;
     }
-    catch (error) {
-        return false;
+    if (!this.captchaDB) {
+      this.captchaDB = new CaptchaDatabase(
+        mongoCaptchaUri,
+        void 0,
+        void 0,
+        this.logger
+      );
     }
-};
-export class ClientTaskManager {
-    constructor(config, logger, db) {
-        this.config = config;
-        this.logger = logger;
-        this.providerDB = db;
+    return this.captchaDB;
+  }
+  /**
+   * @description Store commitments externally in the database (Sends image captcha data to the big Mongo Cloud DB)
+   * @returns Promise<void>
+   */
+  async storeCommitmentsExternal() {
+    if (!this.config.mongoCaptchaUri) {
+      this.logger.info(() => ({ msg: "Mongo env not set" }));
+      return;
     }
-    getCaptchaDB(mongoCaptchaUri) {
-        if (this.captchaDB) {
-            return this.captchaDB;
+    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
+      ScheduledTaskNames.StoreCommitmentsExternal,
+      ScheduledTaskStatus.Completed
+    );
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      ScheduledTaskNames.StoreCommitmentsExternal,
+      ScheduledTaskStatus.Running
+    );
+    try {
+      const BATCH_SIZE = 1e3;
+      const captchaDB = this.getCaptchaDB(this.config.mongoCaptchaUri);
+      let processedCommitments = 0;
+      await this.processBatchesWithCursor(
+        async (skip) => await this.providerDB.getUnstoredDappUserCommitments(
+          BATCH_SIZE,
+          skip
+        ),
+        async (batch) => {
+          const filteredBatch = lastTask?.updated ? batch.filter((commitment) => this.isRecordUpdated(commitment)) : batch;
+          if (filteredBatch.length > 0) {
+            await captchaDB.saveCaptchas([], filteredBatch, []);
+            await this.providerDB.markDappUserCommitmentsStored(
+              filteredBatch.map((commitment) => commitment.id)
+            );
+          }
+          processedCommitments += filteredBatch.length;
         }
-        if (!this.captchaDB) {
-            this.captchaDB = new CaptchaDatabase(mongoCaptchaUri, undefined, undefined, this.logger);
+      );
+      let processedPowRecords = 0;
+      await this.processBatchesWithCursor(
+        async (skip) => await this.providerDB.getUnstoredDappUserPoWCommitments(
+          BATCH_SIZE,
+          skip
+        ),
+        async (batch) => {
+          const filteredBatch = lastTask?.updated ? batch.filter((record) => this.isRecordUpdated(record)) : batch;
+          if (filteredBatch.length > 0) {
+            await captchaDB.saveCaptchas([], [], filteredBatch);
+            await this.providerDB.markDappUserPoWCommitmentsStored(
+              filteredBatch.map((record) => record.challenge)
+            );
+          }
+          processedPowRecords += filteredBatch.length;
         }
-        return this.captchaDB;
-    }
-    async storeCommitmentsExternal() {
-        if (!this.config.mongoCaptchaUri) {
-            this.logger.info(() => ({ msg: "Mongo env not set" }));
-            return;
-        }
-        const lastTask = await this.providerDB.getLastScheduledTaskStatus(ScheduledTaskNames.StoreCommitmentsExternal, ScheduledTaskStatus.Completed);
-        const taskID = await this.providerDB.createScheduledTaskStatus(ScheduledTaskNames.StoreCommitmentsExternal, ScheduledTaskStatus.Running);
-        try {
-            const BATCH_SIZE = 1000;
-            const captchaDB = this.getCaptchaDB(this.config.mongoCaptchaUri);
-            let processedCommitments = 0;
-            await this.processBatchesWithCursor(async (skip) => await this.providerDB.getUnstoredDappUserCommitments(BATCH_SIZE, skip), async (batch) => {
-                const filteredBatch = lastTask?.updated
-                    ? batch.filter((commitment) => this.isRecordUpdated(commitment))
-                    : batch;
-                if (filteredBatch.length > 0) {
-                    await captchaDB.saveCaptchas([], filteredBatch, []);
-                    await this.providerDB.markDappUserCommitmentsStored(filteredBatch.map((commitment) => commitment.id));
-                }
-                processedCommitments += filteredBatch.length;
-            });
-            let processedPowRecords = 0;
-            await this.processBatchesWithCursor(async (skip) => await this.providerDB.getUnstoredDappUserPoWCommitments(BATCH_SIZE, skip), async (batch) => {
-                const filteredBatch = lastTask?.updated
-                    ? batch.filter((record) => this.isRecordUpdated(record))
-                    : batch;
-                if (filteredBatch.length > 0) {
-                    await captchaDB.saveCaptchas([], [], filteredBatch);
-                    await this.providerDB.markDappUserPoWCommitmentsStored(filteredBatch.map((record) => record.challenge));
-                }
-                processedPowRecords += filteredBatch.length;
-            });
-            let processedSessionRecords = 0;
-            await this.processBatchesWithCursor(async (skip) => await this.providerDB.getUnstoredSessionRecords(BATCH_SIZE, skip), async (batch) => {
-                const filteredBatch = lastTask?.updated
-                    ? batch.filter((record) => this.isRecordUpdated(record))
-                    : batch;
-                const frictionlessTokenRecords = await this.providerDB.getFrictionlessTokenRecordsByTokenIds(filteredBatch.map((record) => record.tokenId));
-                this.logger.info(() => ({
-                    msg: `Frictionless token records: ${frictionlessTokenRecords.length}`,
-                }));
-                const filteredBatchWithScores = filteredBatch.map((record) => {
-                    const tokenRecord = frictionlessTokenRecords.find((tokenRecord) => tokenRecord._id?.toString() === record.tokenId.toString());
-                    if (!tokenRecord) {
-                        this.logger.error(() => ({
-                            msg: "No token record found",
-                            data: { tokenId: record.tokenId },
-                        }));
-                        return {
-                            ...record,
-                            score: 0,
-                            scoreComponents: {
-                                baseScore: 0,
-                            },
-                            threshold: 0,
-                        };
-                    }
-                    return {
-                        ...record,
-                        score: tokenRecord?.score || 0,
-                        scoreComponents: tokenRecord?.scoreComponents,
-                        threshold: tokenRecord?.threshold || 0,
-                    };
-                });
-                if (filteredBatch.length > 0) {
-                    await captchaDB.saveCaptchas(filteredBatchWithScores, [], []);
-                    await this.providerDB.markSessionRecordsStored(filteredBatch.map((record) => record.sessionId));
-                }
-                processedSessionRecords += filteredBatch.length;
-            });
-            await this.providerDB.updateScheduledTaskStatus(taskID, ScheduledTaskStatus.Completed, {
-                data: {
-                    processedSessionRecords,
-                    processedCommitments,
-                    processedPowRecords,
+      );
+      let processedSessionRecords = 0;
+      await this.processBatchesWithCursor(
+        async (skip) => await this.providerDB.getUnstoredSessionRecords(BATCH_SIZE, skip),
+        async (batch) => {
+          const filteredBatch = lastTask?.updated ? batch.filter((record) => this.isRecordUpdated(record)) : batch;
+          const frictionlessTokenRecords = await this.providerDB.getFrictionlessTokenRecordsByTokenIds(
+            filteredBatch.map((record) => record.tokenId)
+          );
+          this.logger.info(() => ({
+            msg: `Frictionless token records: ${frictionlessTokenRecords.length}`
+          }));
+          const filteredBatchWithScores = filteredBatch.map((record) => {
+            const tokenRecord = frictionlessTokenRecords.find(
+              (tokenRecord2) => tokenRecord2._id?.toString() === record.tokenId.toString()
+            );
+            if (!tokenRecord) {
+              this.logger.error(() => ({
+                msg: "No token record found",
+                data: { tokenId: record.tokenId }
+              }));
+              return {
+                ...record,
+                score: 0,
+                scoreComponents: {
+                  baseScore: 0
                 },
-            });
-            this.captchaDB?.close();
-        }
-        catch (e) {
-            this.logger.error(() => ({
-                err: e,
-                msg: "Error processing client tasks",
-            }));
-            this.captchaDB?.close();
-            await this.providerDB.updateScheduledTaskStatus(taskID, ScheduledTaskStatus.Failed, { error: String(e) });
-        }
-    }
-    async getClientList() {
-        if (!this.config.mongoClientUri) {
-            this.logger.info(() => ({ msg: "Mongo env not set" }));
-            return;
-        }
-        const lastTask = await this.providerDB.getLastScheduledTaskStatus(ScheduledTaskNames.GetClientList, ScheduledTaskStatus.Completed);
-        const taskID = await this.providerDB.createScheduledTaskStatus(ScheduledTaskNames.GetClientList, ScheduledTaskStatus.Running);
-        try {
-            const clientDB = new ClientDatabase(this.config.mongoClientUri, undefined, undefined, this.logger);
-            const tenMinuteWindow = 10 * 60 * 1000;
-            const updatedAtTimestamp = lastTask?.updated
-                ? lastTask.updated - tenMinuteWindow || 0
-                : 0;
-            this.logger.info(() => ({
-                msg: `Getting updated client records since ${new Date(updatedAtTimestamp).toDateString()}`,
-            }));
-            const newClientRecords = await clientDB.getUpdatedClients(updatedAtTimestamp);
-            if (newClientRecords) {
-                await this.providerDB.updateClientRecords(newClientRecords);
+                threshold: 0
+              };
             }
-            await this.providerDB.updateScheduledTaskStatus(taskID, ScheduledTaskStatus.Completed, {
-                data: {
-                    clientRecords: newClientRecords.length,
-                },
-            });
+            return {
+              ...record,
+              score: tokenRecord?.score || 0,
+              scoreComponents: tokenRecord?.scoreComponents,
+              threshold: tokenRecord?.threshold || 0
+            };
+          });
+          if (filteredBatch.length > 0) {
+            await captchaDB.saveCaptchas(filteredBatchWithScores, [], []);
+            await this.providerDB.markSessionRecordsStored(
+              filteredBatch.map((record) => record.sessionId)
+            );
+          }
+          processedSessionRecords += filteredBatch.length;
         }
-        catch (e) {
-            const getClientListError = new ProsopoApiError("DATABASE.UNKNOWN", {
-                context: { error: e },
-                logger: this.logger,
-            });
-            this.logger.error(() => ({
-                err: getClientListError,
-                msg: "Error getting client list",
-            }));
-            await this.providerDB.updateScheduledTaskStatus(taskID, ScheduledTaskStatus.Failed, { error: String(e) });
+      );
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        ScheduledTaskStatus.Completed,
+        {
+          data: {
+            processedSessionRecords,
+            processedCommitments,
+            processedPowRecords
+          }
         }
+      );
+      this.captchaDB?.close();
+    } catch (e) {
+      this.logger.error(() => ({
+        err: e,
+        msg: "Error processing client tasks"
+      }));
+      this.captchaDB?.close();
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
     }
-    async registerSiteKey(siteKey, tier, settings) {
-        validateSiteKey(siteKey);
-        await this.providerDB.updateClientRecords([
-            {
-                account: siteKey,
-                tier: tier,
-                settings: settings,
-            },
-        ]);
+  }
+  /**
+   * @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(() => ({ msg: "Mongo env not set" }));
+      return;
     }
-    async updateDetectorKey(detectorKey) {
-        if (!isValidPrivateKey(detectorKey)) {
-            throw new ProsopoApiError("INVALID_DETECTOR_KEY", {
-                context: { detectorKey },
-                logger: this.logger,
-            });
+    const lastTask = await this.providerDB.getLastScheduledTaskStatus(
+      ScheduledTaskNames.GetClientList,
+      ScheduledTaskStatus.Completed
+    );
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      ScheduledTaskNames.GetClientList,
+      ScheduledTaskStatus.Running
+    );
+    try {
+      const clientDB = new ClientDatabase(
+        this.config.mongoClientUri,
+        void 0,
+        // expected to come from URI
+        void 0,
+        // expected to come from URI
+        this.logger
+      );
+      const tenMinuteWindow = 10 * 60 * 1e3;
+      const updatedAtTimestamp = lastTask?.updated ? lastTask.updated - tenMinuteWindow || 0 : 0;
+      this.logger.info(() => ({
+        msg: `Getting updated client records since ${new Date(updatedAtTimestamp).toDateString()}`
+      }));
+      const newClientRecords = await clientDB.getUpdatedClients(updatedAtTimestamp);
+      if (newClientRecords) {
+        await this.providerDB.updateClientRecords(newClientRecords);
+      }
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        ScheduledTaskStatus.Completed,
+        {
+          data: {
+            clientRecords: newClientRecords.length
+          }
         }
-        await this.providerDB.storeDetectorKey(detectorKey);
-        const activeDetectorKeys = await this.providerDB.getDetectorKeys();
-        return activeDetectorKeys;
+      );
+    } catch (e) {
+      const getClientListError = new ProsopoApiError("DATABASE.UNKNOWN", {
+        context: { error: e },
+        logger: this.logger
+      });
+      this.logger.error(() => ({
+        err: getClientListError,
+        msg: "Error getting client list"
+      }));
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        ScheduledTaskStatus.Failed,
+        { error: String(e) }
+      );
     }
-    async removeDetectorKey(detectorKey) {
-        if (!isValidPrivateKey(detectorKey)) {
-            throw new ProsopoApiError("INVALID_DETECTOR_KEY", {
-                context: { detectorKey },
-                logger: this.logger,
-            });
-        }
-        await this.providerDB.removeDetectorKey(detectorKey);
+  }
+  async registerSiteKey(siteKey, tier, settings) {
+    validateSiteKey(siteKey);
+    await this.providerDB.updateClientRecords([
+      {
+        account: siteKey,
+        tier,
+        settings
+      }
+    ]);
+  }
+  async updateDetectorKey(detectorKey) {
+    if (!isValidPrivateKey(detectorKey)) {
+      throw new ProsopoApiError("INVALID_DETECTOR_KEY", {
+        context: { detectorKey },
+        logger: this.logger
+      });
     }
-    isSubdomainOrExactMatch(referrer, clientDomain) {
-        if (!referrer || !clientDomain)
-            return false;
-        if (clientDomain === "*")
-            return true;
-        try {
-            const referrerDomain = parseUrl(referrer).hostname.replace(/\.$/, "");
-            const allowedDomain = parseUrl(clientDomain).hostname.replace(/\.$/, "");
-            return (referrerDomain === allowedDomain ||
-                referrerDomain.endsWith(`.${allowedDomain}`));
-        }
-        catch {
-            this.logger.error(() => ({
-                msg: "Error in isSubdomainOrExactMatch",
-                data: { referrer, clientDomain },
-            }));
-            return false;
-        }
+    await this.providerDB.storeDetectorKey(detectorKey);
+    const activeDetectorKeys = await this.providerDB.getDetectorKeys();
+    return activeDetectorKeys;
+  }
+  async removeDetectorKey(detectorKey) {
+    if (!isValidPrivateKey(detectorKey)) {
+      throw new ProsopoApiError("INVALID_DETECTOR_KEY", {
+        context: { detectorKey },
+        logger: this.logger
+      });
     }
-    isRecordUpdated(record) {
-        const { lastUpdatedTimestamp, storedAtTimestamp } = record;
-        return (!lastUpdatedTimestamp ||
-            !storedAtTimestamp ||
-            lastUpdatedTimestamp > storedAtTimestamp);
+    await this.providerDB.removeDetectorKey(detectorKey);
+  }
+  isSubdomainOrExactMatch(referrer, clientDomain) {
+    if (!referrer || !clientDomain) return false;
+    if (clientDomain === "*") return true;
+    try {
+      const referrerDomain = parseUrl(referrer).hostname.replace(/\.$/, "");
+      const allowedDomain = parseUrl(clientDomain).hostname.replace(/\.$/, "");
+      return referrerDomain === allowedDomain || referrerDomain.endsWith(`.${allowedDomain}`);
+    } catch {
+      this.logger.error(() => ({
+        msg: "Error in isSubdomainOrExactMatch",
+        data: { referrer, clientDomain }
+      }));
+      return false;
     }
-    async processBatchesWithCursor(fetchBatch, processBatch) {
-        let skip = 0;
-        while (true) {
-            const batch = await fetchBatch(skip);
-            if (!batch.length)
-                break;
-            await processBatch(batch);
-            skip += batch.length;
-        }
+  }
+  isRecordUpdated(record) {
+    const { lastUpdatedTimestamp, storedAtTimestamp } = record;
+    return !lastUpdatedTimestamp || !storedAtTimestamp || lastUpdatedTimestamp > storedAtTimestamp;
+  }
+  async processBatchesWithCursor(fetchBatch, processBatch) {
+    let skip = 0;
+    while (true) {
+      const batch = await fetchBatch(skip);
+      if (!batch.length) break;
+      await processBatch(batch);
+      skip += batch.length;
     }
+  }
 }
-//# sourceMappingURL=clientTasks.js.map
+export {
+  ClientTaskManager
+};

package/dist/tasks/dataset/datasetTasks.js

@@ -1,19 +1,30 @@
 import { parseCaptchaDataset } from "@prosopo/datasets";
 import { providerValidateDataset } from "./datasetTasksUtils.js";
-export class DatasetManager {
-    constructor(config, logger, captchaConfig, db) {
-        this.config = config;
-        this.logger = logger;
-        this.captchaConfig = captchaConfig;
-        this.db = db;
-    }
-    async providerSetDatasetFromFile(file) {
-        const datasetRaw = parseCaptchaDataset(file);
-        return await this.providerSetDataset(datasetRaw);
-    }
-    async providerSetDataset(datasetRaw) {
-        const dataset = await providerValidateDataset(datasetRaw, this.captchaConfig.solved.count, this.captchaConfig.unsolved.count);
-        await this.db?.storeDataset(dataset);
-    }
+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 = parseCaptchaDataset(file);
+    return await this.providerSetDataset(datasetRaw);
+  }
+  async providerSetDataset(datasetRaw) {
+    const dataset = await providerValidateDataset(
+      datasetRaw,
+      this.captchaConfig.solved.count,
+      this.captchaConfig.unsolved.count
+    );
+    await this.db?.storeDataset(dataset);
+  }
 }
-//# sourceMappingURL=datasetTasks.js.map
+export {
+  DatasetManager
+};

package/dist/tasks/dataset/datasetTasksUtils.js

@@ -1,34 +1,34 @@
 import { ProsopoEnvError } from "@prosopo/common";
 import { buildDataset } from "@prosopo/datasets";
-export const providerValidateDataset = async (datasetRaw, minSolvedCaptchas, minUnsolvedCaptchas) => {
-    if (datasetRaw.captchas.length < minSolvedCaptchas + minUnsolvedCaptchas) {
-        throw new 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 ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
-            context: { failedFuncName: providerValidateDataset.name },
-        });
-    }
-    if (solutions < minUnsolvedCaptchas) {
-        throw new ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
-            context: { failedFuncName: providerValidateDataset.name },
-        });
-    }
-    const dataset = await buildDataset(datasetRaw);
-    if (!dataset.datasetId || !dataset.datasetContentId) {
-        throw new ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
-            context: {
-                failedFuncName: providerValidateDataset.name,
-                datasetId: dataset.datasetId,
-                datasetContentId: dataset.datasetContentId,
-            },
-        });
-    }
-    return dataset;
+const providerValidateDataset = async (datasetRaw, minSolvedCaptchas, minUnsolvedCaptchas) => {
+  if (datasetRaw.captchas.length < minSolvedCaptchas + minUnsolvedCaptchas) {
+    throw new 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 ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  if (solutions < minUnsolvedCaptchas) {
+    throw new ProsopoEnvError("DATASET.SOLUTIONS_COUNT_LESS_THAN_CONFIGURED", {
+      context: { failedFuncName: providerValidateDataset.name }
+    });
+  }
+  const dataset = await buildDataset(datasetRaw);
+  if (!dataset.datasetId || !dataset.datasetContentId) {
+    throw new ProsopoEnvError("DATASET.DATASET_ID_UNDEFINED", {
+      context: {
+        failedFuncName: providerValidateDataset.name,
+        datasetId: dataset.datasetId,
+        datasetContentId: dataset.datasetContentId
+      }
+    });
+  }
+  return dataset;
+};
+export {
+  providerValidateDataset
 };
-//# sourceMappingURL=datasetTasksUtils.js.map