@prosopo/provider 3.2.0 → 3.2.2

package/dist/schedulers/getClientList.js

@@ -3,29 +3,34 @@ import { ScheduledTaskNames } from "@prosopo/types";
 import { CronJob } from "cron";
 import { Tasks } from "../tasks/tasks.js";
 import { checkIfTaskIsRunning } from "../util.js";
-export async function getClientList(pair, cronSchedule, config) {
-    const env = new ProviderEnvironment(config, pair);
-    await env.isReady();
-    const tasks = new Tasks(env);
-    const job = new CronJob(cronSchedule, async () => {
-        const taskRunning = await checkIfTaskIsRunning(ScheduledTaskNames.GetClientList, env.getDb());
-        env.logger.info(() => ({
-            msg: `${ScheduledTaskNames.GetClientList} task running: ${taskRunning}`,
-            data: { taskRunning },
+async function getClientList(pair, cronSchedule, config) {
+  const env = new ProviderEnvironment(config, pair);
+  await env.isReady();
+  const tasks = new Tasks(env);
+  const job = new CronJob(cronSchedule, async () => {
+    const taskRunning = await checkIfTaskIsRunning(
+      ScheduledTaskNames.GetClientList,
+      env.getDb()
+    );
+    env.logger.info(() => ({
+      msg: `${ScheduledTaskNames.GetClientList} task running: ${taskRunning}`,
+      data: { taskRunning }
+    }));
+    if (!taskRunning) {
+      env.logger.info(() => ({
+        msg: `${ScheduledTaskNames.GetClientList} task....`,
+        data: {}
+      }));
+      await tasks.clientTaskManager.getClientList().catch((err) => {
+        env.logger.error(() => ({
+          err,
+          msg: "Error getting client list"
         }));
-        if (!taskRunning) {
-            env.logger.info(() => ({
-                msg: `${ScheduledTaskNames.GetClientList} task....`,
-                data: {},
-            }));
-            await tasks.clientTaskManager.getClientList().catch((err) => {
-                env.logger.error(() => ({
-                    err,
-                    msg: "Error getting client list",
-                }));
-            });
-        }
-    });
-    job.start();
+      });
+    }
+  });
+  job.start();
 }
-//# sourceMappingURL=getClientList.js.map
+export {
+  getClientList
+};

package/dist/tasks/captchaManager.js

@@ -1,96 +1,120 @@
 import { getLogger } from "@prosopo/common";
-import { ApiParams, CaptchaType, Tier } from "@prosopo/types";
+import { CaptchaType, ApiParams, Tier } from "@prosopo/types";
 import { getPrioritisedAccessRule } from "../api/blacklistRequestInspector.js";
-export class CaptchaManager {
-    constructor(db, pair, logger) {
-        this.pair = pair;
-        this.db = db;
-        this.logger = logger || getLogger("info", import.meta.url);
-    }
-    async getFrictionlessTokenIdFromSession(sessionRecord) {
-        const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(sessionRecord.tokenId);
-        return tokenRecord ? tokenRecord._id : undefined;
+class CaptchaManager {
+  constructor(db, pair, logger) {
+    this.pair = pair;
+    this.db = db;
+    this.logger = logger || getLogger("info", import.meta.url);
+  }
+  async getFrictionlessTokenIdFromSession(sessionRecord) {
+    const tokenRecord = await this.db.getFrictionlessTokenRecordByTokenId(
+      sessionRecord.tokenId
+    );
+    return tokenRecord ? tokenRecord._id : void 0;
+  }
+  async isValidRequest(clientSettings, requestedCaptchaType, sessionId, userAccessPolicy) {
+    this.logger.debug(() => ({
+      msg: "Validating request",
+      data: {
+        captchaType: requestedCaptchaType,
+        sessionId
+      }
+    }));
+    if (userAccessPolicy && userAccessPolicy.captchaType !== requestedCaptchaType) {
+      this.logger.warn(() => ({
+        msg: "Invalid captcha type for user access policy",
+        data: {
+          account: clientSettings.account,
+          captchaType: userAccessPolicy.captchaType
+        }
+      }));
+      return {
+        valid: false,
+        reason: "API.INCORRECT_CAPTCHA_TYPE",
+        type: requestedCaptchaType
+      };
     }
-    async isValidRequest(clientSettings, captchaType, sessionId) {
-        this.logger.debug(() => ({
-            msg: "Validating request",
+    if (sessionId) {
+      if (clientSettings?.settings?.captchaType === CaptchaType.frictionless) {
+        const sessionRecord = await this.db.checkAndRemoveSession(sessionId);
+        if (!sessionRecord) {
+          this.logger.warn(() => ({
+            msg: "No frictionless session found",
             data: {
-                captchaType,
-                sessionId,
-            },
-        }));
-        if (sessionId) {
-            if (clientSettings?.settings?.captchaType === CaptchaType.frictionless) {
-                const sessionRecord = await this.db.checkAndRemoveSession(sessionId);
-                if (!sessionRecord) {
-                    this.logger.warn(() => ({
-                        msg: "No frictionless session found",
-                        data: {
-                            account: clientSettings.account,
-                            sessionId: sessionId,
-                        },
-                    }));
-                    return {
-                        valid: false,
-                        reason: "CAPTCHA.NO_SESSION_FOUND",
-                        type: captchaType,
-                    };
-                }
-                const frictionlessTokenId = await this.getFrictionlessTokenIdFromSession(sessionRecord);
-                return {
-                    valid: true,
-                    frictionlessTokenId,
-                    type: captchaType,
-                };
+              account: clientSettings.account,
+              sessionId
             }
-            this.logger.warn(() => ({
-                msg: "Invalid frictionless request",
-                data: {
-                    account: clientSettings.account,
-                    sessionId: sessionId,
-                    settingsCaptchaType: clientSettings?.settings?.captchaType,
-                },
-            }));
-            return {
-                valid: false,
-                reason: "API.INCORRECT_CAPTCHA_TYPE",
-                type: captchaType,
-            };
+          }));
+          return {
+            valid: false,
+            reason: "CAPTCHA.NO_SESSION_FOUND",
+            type: requestedCaptchaType
+          };
         }
-        if (clientSettings?.settings?.captchaType !== captchaType) {
-            this.logger.warn(() => ({
-                msg: `Invalid ${captchaType} request`,
-                data: {
-                    account: clientSettings.account,
-                    requestedCaptchaType: captchaType,
-                    settingsCaptchaType: clientSettings?.settings?.captchaType,
-                },
-            }));
-            return {
-                valid: false,
-                reason: "API.INCORRECT_CAPTCHA_TYPE",
-                type: captchaType,
-            };
-        }
-        return { valid: true, type: captchaType };
-    }
-    getVerificationResponse(verified, clientRecord, translateFn, score) {
+        const frictionlessTokenId = await this.getFrictionlessTokenIdFromSession(sessionRecord);
         return {
-            status: translateFn(verified ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"),
-            [ApiParams.verified]: verified,
-            ...(CaptchaManager.canClientSeeScore(clientRecord.tier, score) && {
-                [ApiParams.score]: score,
-            }),
+          valid: true,
+          frictionlessTokenId,
+          type: requestedCaptchaType
         };
+      }
+      this.logger.warn(() => ({
+        msg: "Invalid frictionless request",
+        data: {
+          account: clientSettings.account,
+          sessionId,
+          settingsCaptchaType: clientSettings?.settings?.captchaType
+        }
+      }));
+      return {
+        valid: false,
+        reason: "API.INCORRECT_CAPTCHA_TYPE",
+        type: requestedCaptchaType
+      };
     }
-    async getPrioritisedAccessPolicies(userAccessRulesStorage, clientId, userScope) {
-        return getPrioritisedAccessRule(userAccessRulesStorage, userScope, clientId);
-    }
-    async getDetectorKeys() {
-        return await this.db.getDetectorKeys();
-    }
-    static canClientSeeScore(tier, score) {
-        return score && tier && tier !== Tier.Free;
+    if (clientSettings?.settings?.captchaType !== requestedCaptchaType) {
+      this.logger.warn(() => ({
+        msg: `Invalid ${requestedCaptchaType} request`,
+        data: {
+          account: clientSettings.account,
+          requestedCaptchaType,
+          settingsCaptchaType: clientSettings?.settings?.captchaType
+        }
+      }));
+      return {
+        valid: false,
+        reason: "API.INCORRECT_CAPTCHA_TYPE",
+        type: requestedCaptchaType
+      };
     }
+    return { valid: true, type: requestedCaptchaType };
+  }
+  getVerificationResponse(verified, clientRecord, translateFn, score) {
+    return {
+      status: translateFn(
+        verified ? "API.USER_VERIFIED" : "API.USER_NOT_VERIFIED"
+      ),
+      [ApiParams.verified]: verified,
+      ...CaptchaManager.canClientSeeScore(clientRecord.tier, score) && {
+        [ApiParams.score]: score
+      }
+    };
+  }
+  async getPrioritisedAccessPolicies(userAccessRulesStorage, clientId, userScope) {
+    return getPrioritisedAccessRule(
+      userAccessRulesStorage,
+      userScope,
+      clientId
+    );
+  }
+  async getDetectorKeys() {
+    return await this.db.getDetectorKeys();
+  }
+  static canClientSeeScore(tier, score) {
+    return score && tier && tier !== Tier.Free;
+  }
 }
-//# sourceMappingURL=captchaManager.js.map
+export {
+  CaptchaManager
+};