feat: add threshold in DateProvider

lib/ts/claims/primitiveArrayClaim.ts

@@ -33,7 +33,7 @@ export class PrimitiveArrayClaim<ValueType> {
             id?: string
         ): SessionClaimValidator => {
             const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
-            if (maxAgeInSeconds && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
+            if (maxAgeInSeconds !== undefined && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
                 throw new Error(
                     `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
                 );
@@ -80,7 +80,7 @@ export class PrimitiveArrayClaim<ValueType> {
             id?: string
         ): SessionClaimValidator => {
             const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
-            if (maxAgeInSeconds && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
+            if (maxAgeInSeconds !== undefined && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
                 throw new Error(
                     `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
                 );
@@ -131,7 +131,7 @@ export class PrimitiveArrayClaim<ValueType> {
             id?: string
         ): SessionClaimValidator => {
             const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
-            if (maxAgeInSeconds && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
+            if (maxAgeInSeconds !== undefined && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
                 throw new Error(
                     `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
                 );
@@ -179,7 +179,7 @@ export class PrimitiveArrayClaim<ValueType> {
             id?: string
         ): SessionClaimValidator => {
             const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
-            if (maxAgeInSeconds && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
+            if (maxAgeInSeconds !== undefined && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
                 throw new Error(
                     `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
                 );
@@ -231,7 +231,7 @@ export class PrimitiveArrayClaim<ValueType> {
             id?: string
         ): SessionClaimValidator => {
             const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
-            if (maxAgeInSeconds && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
+            if (maxAgeInSeconds !== undefined && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
                 throw new Error(
                     `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
                 );

lib/ts/claims/primitiveClaim.ts

@@ -33,18 +33,22 @@ export class PrimitiveClaim<ValueType> {
             id?: string
         ): SessionClaimValidator => {
             const DateProvider = DateProviderReference.getReferenceOrThrow().dateProvider;
-            if (maxAgeInSeconds && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
-                throw new Error(
-                    `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
-                );
-            }
             return {
                 id: id !== undefined ? id : this.id,
                 refresh: ctx => this.refresh(ctx),
-                shouldRefresh: (payload, ctx) =>
-                    this.getValueFromPayload(payload, ctx) === undefined ||
-                    // We know payload[this.id] is defined since the value is not undefined in this branch
-                    (maxAgeInSeconds !== undefined && payload[this.id].t < DateProvider.now() - maxAgeInSeconds * 1000),
+                shouldRefresh: (payload, ctx) => {
+                    if (maxAgeInSeconds !== undefined && maxAgeInSeconds < DateProvider.getThresholdInSeconds()) {
+                        throw new Error(
+                            `maxAgeInSeconds must be greater than the DateProvider threshold value -> ${DateProvider.getThresholdInSeconds()}`
+                        );
+                    }
+                    return (
+                        this.getValueFromPayload(payload, ctx) === undefined ||
+                        // We know payload[this.id] is defined since the value is not undefined in this branch
+                        (maxAgeInSeconds !== undefined &&
+                            payload[this.id].t < DateProvider.now() - maxAgeInSeconds * 1000)
+                    );
+                },
                 validate: (payload, ctx) => {
                     const claimVal = this.getValueFromPayload(payload, ctx);
                     if (claimVal === undefined) {

lib/ts/fetch.ts

@@ -951,7 +951,7 @@ export const updateClockSkewUsingFrontToken = ({
     }
 
     const frontTokenPayload = parseFrontToken(frontToken);
-    const clockSkewInMillis = AuthHttpRequest.recipeImpl.getClockSkewInMillis({
+    const clockSkewInMillis = AuthHttpRequest.recipeImpl.calculateClockSkewInMillis({
         accessTokenPayload: frontTokenPayload.up,
         responseHeaders
     });

lib/ts/recipeImplementation.ts

@@ -311,25 +311,25 @@ export default function RecipeImplementation(recipeImplInput: {
             }
         },
 
-        getClockSkewInMillis: function ({
+        calculateClockSkewInMillis: function ({
             accessTokenPayload
         }: {
             accessTokenPayload: any;
             responseHeaders: Headers;
         }): number {
-            logDebugMessage("getClockSkewInMillis: called");
+            logDebugMessage("calculateClockSkewInMillis: called");
 
             const tokenIssuedAt = accessTokenPayload?.iat;
             if (tokenIssuedAt === undefined || typeof tokenIssuedAt !== "number") {
                 logDebugMessage(
-                    `getClockSkewInMillis: payload iat is undefined or not a number. This may happen due to an unsupported backend sdk. Returning 0`
+                    `calculateClockSkewInMillis: payload iat is undefined or not a number. This may happen due to an unsupported backend sdk. Returning 0`
                 );
                 return 0;
             }
 
             const estimatedServerTimeNow = tokenIssuedAt * 1000;
             const clockSkewInMillis = estimatedServerTimeNow - Date.now();
-            logDebugMessage("getClockSkewInMillis: returning " + clockSkewInMillis);
+            logDebugMessage("calculateClockSkewInMillis: returning " + clockSkewInMillis);
 
             return clockSkewInMillis;
         }

lib/ts/types.ts

@@ -153,7 +153,7 @@ export type RecipeInterface = {
         sessionTokenBackendDomain: string | undefined
     ): boolean;
 
-    getClockSkewInMillis(params: { accessTokenPayload: any; responseHeaders: Headers }): number;
+    calculateClockSkewInMillis(params: { accessTokenPayload: any; responseHeaders: Headers }): number;
 };
 
 export type ClaimValidationResult = { isValid: true } | { isValid: false; reason?: any };

lib/ts/utils/dateProvider/defaultImplementation.ts

@@ -63,6 +63,10 @@ export class DateProvider {
         return this.thresholdInSeconds;
     }
 
+    setThresholdInSeconds(thresholdInSeconds: number): void {
+        this.thresholdInSeconds = thresholdInSeconds;
+    }
+
     setClientClockSkewInMillis(clockSkewInMillis: number): void {
         this.clockSkewInMillis = Math.abs(clockSkewInMillis) > this.thresholdInSeconds * 1000 ? clockSkewInMillis : 0;
         const localStorage = WindowHandlerReference.getReferenceOrThrow().windowHandler.localStorage;

lib/ts/utils/dateProvider/types.ts

@@ -15,6 +15,7 @@
 
 export interface DateProviderInterface {
     getThresholdInSeconds(): number;
+    setThresholdInSeconds(thresholdInSeconds: number): void;
     now(): number;
     setClientClockSkewInMillis(clockSkewInMillis: number): void;
     getClientClockSkewInMillis(): number;

test/interception.claims.test.js

@@ -85,7 +85,7 @@ addGenericTestCases((name, transferMethod, setupFunc, setupArgs = []) => {
                         {
                             // enableDebugLogs: true,
                             // This isn't used in all tests but it only produces some extra logs
-                            override: ["log_getClockSkewInMillis"]
+                            override: ["log_calculateClockSkewInMillis"]
                         },
                         ...setupArgs
                     );
@@ -266,7 +266,7 @@ addGenericTestCases((name, transferMethod, setupFunc, setupArgs = []) => {
             }
         });
 
-        it("should call the claim refresh endpoint once for multiple `shouldRefresh` calls with adjusted clock skew (client clock behind)", async function () {
+        it("should call the claim refresh endpoint as many times as `shouldRefresh` calls with adjusted clock skew (client clock behind)", async function () {
             await startST(2 * 60 * 60); // setting accessTokenValidity to 2 hours to avoid refresh issues due to clock skew
             try {
                 let customClaimRefreshCalledCount = 0;
@@ -317,7 +317,12 @@ addGenericTestCases((name, transferMethod, setupFunc, setupArgs = []) => {
                                 body: JSON.stringify({
                                     "st-custom": {
                                         v: true,
-                                        t: originalNow()
+                                        // We intentionally expire the claim during an update. In an ideal scenario,
+                                        // the `shouldRefresh` function would consistently return true as the claim is expired.
+                                        // However, if the client clock is behind, the `shouldRefresh` function may erroneously return false.
+                                        // The responsibility of handling this situation lies with the DateProvider,
+                                        // ensuring that `shouldRefresh` correctly returns true regardless of potential clock discrepancies.
+                                        t: originalNow() - 10 * 60 * 1000
                                     }
                                 })
                             });
@@ -332,19 +337,18 @@ addGenericTestCases((name, transferMethod, setupFunc, setupArgs = []) => {
                     await supertokens.validateClaims(() => [customSessionClaimValidator]);
                 });
 
-                assert.strictEqual(customClaimRefreshCalledCount, 1);
+                assert.strictEqual(customClaimRefreshCalledCount, 3);
             } finally {
                 await browser.close();
             }
         });
 
-        it("should call getClockSkewInMillis with appropriate headers", async function () {
+        it("should call calculateClockSkewInMillis with appropriate headers", async function () {
             await startST();
             let clockSkewParams = [];
             page.on("console", ev => {
                 const text = ev.text();
-                // console.log(text);
-                const key = "TEST_getClockSkewInMillis$";
+                const key = "TEST_calculateClockSkewInMillis$";
                 if (text.startsWith(key)) {
                     clockSkewParams.push(JSON.parse(text.substr(key.length)));
                 }