fix(email_verification): should refresh email verification is called once per second

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
+-   Added a debounced mechanism in should refresh email verification to limit verification call to once per second.
+
 ## [0.14.0] - 2024-10-07
 
 -   Added the OAuth2Provider recipe

lib/ts/recipe/emailverification/emailVerificationClaim.ts

@@ -28,6 +28,11 @@ export class EmailVerificationClaimClass extends BooleanClaim {
                 refresh: this.refresh,
                 shouldRefresh: (payload, userContext) => {
                     const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
+                    const currentTime = DateProvider.now();
+
+                    if (this.shouldRefreshLastCalled && this.shouldRefreshLastCalled > currentTime - 1000) {
+                        return false;
+                    }
 
                     refetchTimeOnFalseInSeconds = refetchTimeOnFalseInSeconds ?? getThresholdAwareDefaultValue(10);
 
@@ -46,20 +51,22 @@ export class EmailVerificationClaimClass extends BooleanClaim {
                     const value = this.getValueFromPayload(payload, userContext);
 
                     if (value === undefined) {
+                        this.shouldRefreshLastCalled = currentTime;
                         return true;
                     }
 
-                    const currentTime = DateProvider.now();
                     const lastRefetchTime = this.getLastFetchedTime(payload, userContext)!;
 
                     if (maxAgeInSeconds !== undefined) {
                         if (lastRefetchTime < currentTime - maxAgeInSeconds * 1000) {
+                            this.shouldRefreshLastCalled = currentTime;
                             return true;
                         }
                     }
 
                     if (value === false) {
                         if (lastRefetchTime < currentTime - refetchTimeOnFalseInSeconds * 1000) {
+                            this.shouldRefreshLastCalled = currentTime;
                             return true;
                         }
                     }
@@ -82,4 +89,6 @@ export class EmailVerificationClaimClass extends BooleanClaim {
     validators!: BooleanClaim["validators"] & {
         isVerified: (refetchTimeOnFalseInSeconds?: number, maxAgeInSeconds?: number) => SessionClaimValidator;
     };
+
+    shouldRefreshLastCalled?: number;
 }

lib/ts/recipe/emailverification/index.ts

@@ -19,7 +19,9 @@ import { getNormalisedUserContext } from "../../utils";
 import { EmailVerificationClaimClass } from "./emailVerificationClaim";
 
 export default class RecipeWrapper {
-    static EmailVerificationClaim = Recipe.EmailVerificationClaim;
+    static get EmailVerificationClaim() {
+        return Recipe.EmailVerificationClaim;
+    }
 
     static init(config?: UserInput) {
         return Recipe.init(config);

lib/ts/recipe/emailverification/recipe.ts

@@ -85,7 +85,9 @@ export default class Recipe implements RecipeModule<PreAndPostAPIHookAction, Nor
             return;
         }
         Recipe.instance = undefined;
-        return;
+        Recipe.EmailVerificationClaim = new EmailVerificationClaimClass(
+            () => Recipe.getInstanceOrThrow().recipeImplementation
+        );
     }
 }
 

test/unit/emailverificationclaim.test.js

@@ -14,39 +14,61 @@
  */
 import jsdom from "mocha-jsdom";
 import EmailVerification from "../../recipe/emailverification";
+import EmailVerificationRecipe from "../../lib/build/recipe/emailverification/recipe";
 import SuperTokens from "../../lib/build/supertokens";
 import assert from "assert";
 
+/*
+ * Delay function is used in case of email verification claim as we have added a debouncing
+ * mechanism that shouldRefresh will return false if multiple calls are done in 1000ms.
+ * Hence adding delay after each email verification or shouldRefresh calls will result in
+ * correct tests.
+ * Test for checking when the shouldRefresh returning false when called multiple times in 1000ms
+ * is added.
+ */
+let delayCounter = 0;
+const delay = async () => {
+    ++delayCounter;
+};
+
+const commonConfig = {
+    appInfo: {
+        appName: "SuperTokens",
+        apiDomain: "api.supertokens.io",
+    },
+    dateProvider: function () {
+        return {
+            getThresholdInSeconds: function () {
+                return 7;
+            },
+            now: function () {
+                return Date.now() + delayCounter * 1000;
+            },
+        };
+    },
+    recipeList: [EmailVerification.init()],
+};
+
 describe("EmailVerificationClaim test", function () {
     jsdom({ url: "http://localhost.org" });
 
     beforeEach(function () {
         SuperTokens.reset();
+        EmailVerificationRecipe.reset();
+        delayCounter = 0;
     });
 
     describe("EmailVerification Claim", function () {
         it("value should be refreshed if it is undefined", async function () {
-            SuperTokens.init({
-                appInfo: {
-                    appName: "SuperTokens",
-                    apiDomain: "api.supertokens.io",
-                },
-                recipeList: [EmailVerification.init()],
-            });
+            SuperTokens.init(commonConfig);
 
             const validator = EmailVerification.EmailVerificationClaim.validators.isVerified();
             const shouldRefreshUndefined = await validator.shouldRefresh({});
             assert.strictEqual(shouldRefreshUndefined, true);
         });
 
         it("value should be refreshed as per maxAgeInSeconds if it is provided", async function () {
-            SuperTokens.init({
-                appInfo: {
-                    appName: "SuperTokens",
-                    apiDomain: "api.supertokens.io",
-                },
-                recipeList: [EmailVerification.init()],
-            });
+            SuperTokens.init(commonConfig);
 
             const validator = EmailVerification.EmailVerificationClaim.validators.isVerified(10, 200);
             const shouldRefreshValid = await validator.shouldRefresh({
@@ -60,13 +82,7 @@ describe("EmailVerificationClaim test", function () {
         });
 
         it("value should be refreshed as per refetchTimeOnFalseInSeconds if it is provided", async function () {
-            SuperTokens.init({
-                appInfo: {
-                    appName: "SuperTokens",
-                    apiDomain: "api.supertokens.io",
-                },
-                recipeList: [EmailVerification.init()],
-            });
+            SuperTokens.init(commonConfig);
 
             const validator = EmailVerification.EmailVerificationClaim.validators.isVerified(8);
             const shouldRefreshValid = await validator.shouldRefresh({
@@ -80,24 +96,34 @@ describe("EmailVerificationClaim test", function () {
         });
 
         it("value should be refreshed as per default the refetchTimeOnFalseInSeconds if it is not provided", async function () {
-            SuperTokens.init({
-                appInfo: {
-                    appName: "SuperTokens",
-                    apiDomain: "api.supertokens.io",
-                },
-                recipeList: [EmailVerification.init()],
-            });
+            SuperTokens.init(commonConfig);
 
             // NOTE: the default value of refetchTimeOnFalseInSeconds is 10 seconds
             const validator = EmailVerification.EmailVerificationClaim.validators.isVerified();
             const shouldRefreshValid = await validator.shouldRefresh({
                 "st-ev": { v: false, t: Date.now() - 9 * 1000 },
             });
+            await delay(); // Added for correct results, since shouldRefresh is debounced
             const shouldRefreshExpired = await validator.shouldRefresh({
                 "st-ev": { v: false, t: Date.now() - 11 * 1000 },
             });
             assert.strictEqual(shouldRefreshValid, false);
             assert.strictEqual(shouldRefreshExpired, true);
         });
+
+        it("shouldRefresh should return false if called before 1000ms", async function () {
+            SuperTokens.init(commonConfig);
+
+            // NOTE: the default value of refetchTimeOnFalseInSeconds is 10 seconds
+            const validator = EmailVerification.EmailVerificationClaim.validators.isVerified();
+            const shouldRefresh = await validator.shouldRefresh({
+                "st-ev": { v: false, t: Date.now() - 11 * 1000 },
+            });
+            const shouldRefreshAgain = await validator.shouldRefresh({
+                "st-ev": { v: false, t: Date.now() - 11 * 1000 },
+            });
+            assert.strictEqual(shouldRefresh, true);
+            assert.strictEqual(shouldRefreshAgain, false);
+        });
     });
 });