Clear tokens and store expiration time.

Author: SebastianStehle

src/wrapper/SquidexClient.ts

@@ -14,39 +14,24 @@ export declare namespace SquidexClient {
     }
 
     export interface TokenStore {
-        get(): string | undefined;
-
-        set(token: string): void;
-    }
-}
+        get(): Token | undefined;
 
+        set(token: Token): void;
 
-export class SquidexInMemoryTokenStore implements SquidexClient.TokenStore {
-    private token: string | undefined;
-
-    get(): string | undefined {
-        return this.token;
+        clear(): void;
     }
 
-    set(token: string): void {
-        this.token = token;
-    }
-}
-
-export class SquidexStorageTokenStore implements SquidexClient.TokenStore {
-    constructor(readonly store: Storage = localStorage, readonly key = 'SquidexToken') {
-    }
-
-    get(): string | undefined {
-        return this.store.getItem(this.key) || undefined;
-    }
-
-    set(token: string): void {
-        this.store.setItem(this.key, token);
+    export interface Token {
+        accessToken: string;
+        expiresIn: number;
+        expiresAt: number;
     }
 }
 
 export class SquidexClient extends FernClient {
+    private tokenPromise?: Promise<string>;
+    private tokenStore?: SquidexClient.TokenStore;
+
     public get appName() {
         return this.options.appName;
     }
@@ -63,41 +48,44 @@ export class SquidexClient extends FernClient {
         return this.clientOptions.environment || environments.SquidexEnvironment.Default;
     }
 
+    private get actualTokenStore() {
+        return this.tokenStore ||= (this.clientOptions.tokenStore || new SquidexClient.InMemoryTokenStore());
+    }
+
     constructor(readonly clientOptions: SquidexClient.Options) {
         super({
-            environment: clientOptions.environment,
             appName: clientOptions.appName,
-            token: buildTokenResolver(clientOptions)
+            token: () => {
+                return this.getToken();
+            },
+            environment: clientOptions.environment
         });
     }
-}
 
-function buildTokenResolver(options: SquidexClient.Options) {
-    const store = options.tokenStore || new SquidexInMemoryTokenStore();
-    
-    const cachedPromise: {
-        promise?: Promise<string>
-    } = {};
+    clearToken() {
+        this.actualTokenStore.clear();
+    }
 
-    return () => {
-        const promise = (cachedPromise.promise ||= (async () => {
+    private async getToken() {
+        const promise = (this.tokenPromise ||= (async () => {
+            const now = new Date().getTime();
             try {
-                let token = store.get();
+                let token = this.actualTokenStore.get();
 
-                if (token != null) {
-                    return token;
+                if (token != null && token.expiresAt > now) {
+                    return token.accessToken;
                 }
 
                 const response = await core.fetcher({
                     url: urlJoin(
-                        options.environment ?? environments.SquidexEnvironment.Default,
+                        this.clientOptions.environment ?? environments.SquidexEnvironment.Default,
                         "/identity-server/connect/token"
                     ),
                     contentType: "application/x-www-form-urlencoded",
                     body: new URLSearchParams({
                         grant_type: "client_credentials",
-                        client_id: options.clientId,
-                        client_secret: options.clientSecret,
+                        client_id: this.clientOptions.clientId,
+                        client_secret: this.clientOptions.clientSecret,
                         scope: "squidex-api",
                     }),
                     method: "POST",
@@ -110,7 +98,19 @@ function buildTokenResolver(options: SquidexClient.Options) {
                             message: "Token is not a string",
                         });
                     }
-                    token = accessToken;
+
+                    const expiresIn: number = (response.body as any)?.["expires_in"];
+                    if (typeof expiresIn !== "number") {
+                        throw new errors.SquidexError({
+                            message: "Token has no valid expiration",
+                        });
+                    }
+                    
+                    token = { 
+                        accessToken,
+                        expiresIn,
+                        expiresAt: now + expiresIn
+                    };
                 } else {
                     switch (response.error.reason) {
                         case "non-json":
@@ -134,20 +134,61 @@ function buildTokenResolver(options: SquidexClient.Options) {
                     }
                 }
 
-                store.set(token);
+                this.actualTokenStore.set(token);
 
                 if (token == null) {
                     throw new errors.SquidexError({
                         message: "Token is null despite trying to fetch",
                     });
                 }
 
-                return token;
+                return token.accessToken;
             } finally {
-                cachedPromise.promise = undefined;
+                this.tokenPromise = undefined;
             }
         })());
 
         return promise;
+    };
+}
+
+export namespace SquidexClient {
+    export class InMemoryTokenStore implements TokenStore {
+        private token: Token | undefined;
+    
+        get(): Token | undefined {
+            return this.token;
+        }
+    
+        set(token: Token): void {
+            this.token = token;
+        }
+    
+        clear() {
+            this.token = undefined;
+        }
+    }
+
+    export class StorageTokenStore implements TokenStore {
+        constructor(readonly store: Storage = localStorage, readonly key = 'SquidexToken') {
+        }
+    
+        get(): Token | undefined {
+            const value = this.store.getItem(this.key);
+    
+            if (!value) {
+                return undefined;
+            }
+    
+            return JSON.parse(value);
+        }
+    
+        set(token: Token): void {
+            this.store.setItem(this.key, JSON.stringify(token));
+        }
+    
+        clear() {
+            this.store.removeItem(this.key);
+        }
     }
 }

tests/globalSetup.ts

@@ -4,7 +4,7 @@ import { getEnvironment, getClient, delay } from "./_utils";
 async function setup() {
     console.log('SETUP');
 
-    const { client } = getClient(true);
+    const { client } = getClient();
 
     const waitTime = parseInt(getEnvironment("CONFIG__WAIT", "0"), 10);