zavadil-ts-common 1.2.41 → 1.2.43

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "zavadil-ts-common",
-	"version": "1.2.41",
+	"version": "1.2.43",
 	"description": "Common types and components for Typescript UI apps.",
 	"main": "dist/index.js",
 	"module": "dist/index.esm.js",

package/src/cache/CacheAsync.ts

@@ -1,28 +1,21 @@
-export class CacheAsync<T> {
+import {LazyAsync} from "./LazyAsync";
 
-	private cache?: T;
-
-	private supplier: () => Promise<T>;
+export class CacheAsync<T> extends LazyAsync<T> {
 
 	private maxAgeMs?: number;
 
 	private expires?: Date;
 
 	constructor(supplier: () => Promise<T>, maxAgeMs?: number) {
-		this.supplier = supplier;
+		super(supplier);
 		this.maxAgeMs = maxAgeMs;
 	}
 
 	get(): Promise<T> {
-		if (this.cache === undefined || (this.expires && this.expires > new Date())) {
-			return this.supplier()
-				.then((v: T) => {
-					this.set(v);
-					return v;
-				});
-		} else {
-			return Promise.resolve(this.cache);
+		if (this.expires && this.expires > new Date()) {
+			this.reset();
 		}
+		return super.get();
 	}
 
 	set(v: T, expires?: Date) {
@@ -33,11 +26,4 @@ export class CacheAsync<T> {
 		}
 	}
 
-	hasCache() {
-		return (this.cache !== undefined);
-	}
-
-	getCache(): T | undefined {
-		return this.cache;
-	}
 }

package/src/cache/LazyAsync.ts

@@ -1,8 +1,8 @@
 export class LazyAsync<T> {
 
-	private cache?: T;
+	protected cache?: T;
 
-	private supplier: () => Promise<T>;
+	protected supplier: () => Promise<T>;
 
 	private promise?: Promise<T>;
 

package/src/oauth/OAuthTokenManager.ts

@@ -1,15 +1,12 @@
 import {AccessTokenPayload, IdTokenPayload, OAuthRestClient} from "./OAuthRestClient";
-import {EventManager} from "../component";
-import {StringUtil} from "../util";
 import {OAuthIdTokenProvider} from "./tokenprovider/OAuthIdTokenProvider";
+import {OAuthUtil} from "../util/OAuthUtil";
 
 /**
  * Manages refresh of id and access tokens.
  */
 export class OAuthTokenManager implements OAuthIdTokenProvider {
 
-	private eventManager: EventManager = new EventManager();
-
 	oAuthServer: OAuthRestClient;
 
 	audience: string;
@@ -27,45 +24,16 @@ export class OAuthTokenManager implements OAuthIdTokenProvider {
 		this.accessTokens = new Map<string, AccessTokenPayload>();
 	}
 
-	addIdTokenChangedHandler(handler: (t: IdTokenPayload) => any) {
-		this.eventManager.addEventListener('id-token-changed', handler);
-	}
-
-	removeIdTokenChangedHandler(handler: (t: IdTokenPayload) => any) {
-		this.eventManager.removeEventListener('id-token-changed', handler);
-	}
-
-	isTokenExpired(expires?: Date | null): boolean {
-		if (expires === undefined || expires === null) return false;
-		return (expires < new Date());
-	}
-
-	isTokenReadyForRefresh(issuedAt: Date, expires?: Date | null): boolean {
-		if (expires === undefined || expires === null) return false;
-		const middle = new Date((expires.getTime() + issuedAt.getTime()) / 2);
-		const now = new Date();
-		return (middle < now);
-	}
-
-	isValidIdToken(idToken?: IdTokenPayload): boolean {
-		return idToken !== undefined && StringUtil.notEmpty(idToken.token) && !this.isTokenExpired(idToken.expires);
-	}
-
 	hasValidIdToken(): boolean {
-		return this.isValidIdToken(this.idToken);
-	}
-
-	isValidAccessToken(accessToken?: AccessTokenPayload): boolean {
-		return accessToken !== undefined && StringUtil.notEmpty(accessToken.token) && !this.isTokenExpired(accessToken.expires);
+		return OAuthUtil.isValidToken(this.idToken);
 	}
 
 	hasValidAccessToken(privilege: string): boolean {
-		return this.isValidAccessToken(this.accessTokens.get(privilege));
+		return OAuthUtil.isValidToken(this.accessTokens.get(privilege));
 	}
 
 	reset() {
 		this.idToken = undefined;
-		this.eventManager.triggerEvent('id-token-changed', undefined);
 		this.accessTokens.clear();
 	}
 
@@ -86,7 +54,10 @@ export class OAuthTokenManager implements OAuthIdTokenProvider {
 		return this.getIdTokenInternal()
 			.then(
 				(t: IdTokenPayload) => {
-					if (this.isTokenReadyForRefresh(t.issuedAt, t.expires)) {
+					if (!OAuthUtil.isValidToken(t)) {
+						return Promise.reject('Received invalid ID token!');
+					}
+					if (OAuthUtil.isTokenReadyForRefresh(t)) {
 						return this.oAuthServer
 							.refreshIdToken({idToken: t.token})
 							.then(
@@ -107,11 +78,7 @@ export class OAuthTokenManager implements OAuthIdTokenProvider {
 	}
 
 	setIdToken(token?: IdTokenPayload) {
-		if (!this.isValidIdToken(token)) {
-			throw new Error("Received ID token is not valid!");
-		}
 		this.idToken = token;
-		this.eventManager.triggerEvent('id-token-changed', token);
 	}
 
 	verifyIdToken(token: string): Promise<IdTokenPayload> {
@@ -131,7 +98,7 @@ export class OAuthTokenManager implements OAuthIdTokenProvider {
 				(idToken: string) => this.oAuthServer
 					.requestAccessToken({idToken: idToken, targetAudience: this.audience, privilege: privilege})
 					.then((act: AccessTokenPayload) => {
-						if (!this.isValidAccessToken(act)) {
+						if (!OAuthUtil.isValidToken(act)) {
 							return Promise.reject("Received access token is not valid!");
 						}
 						this.accessTokens.set(privilege, act);
@@ -142,9 +109,9 @@ export class OAuthTokenManager implements OAuthIdTokenProvider {
 
 	getAccessToken(privilege: string): Promise<string> {
 		const existing = this.accessTokens.get(privilege);
-		if (existing === undefined || !this.isValidAccessToken(existing)) return this.getAccessTokenInternal(privilege).then((t) => t.token);
+		if (existing === undefined || !OAuthUtil.isValidToken(existing)) return this.getAccessTokenInternal(privilege).then((t) => t.token);
 		// preload access token if it is going to expire soon
-		if (this.isTokenReadyForRefresh(existing.issuedAt, existing.expires)) this.getAccessTokenInternal(privilege);
+		if (OAuthUtil.isTokenReadyForRefresh(existing)) this.getAccessTokenInternal(privilege);
 		return Promise.resolve(existing.token);
 	}
 

package/src/oauth/tokenprovider/IdTokenProviderDefault.ts

@@ -2,7 +2,7 @@ import {OAuthIdTokenProvider} from "./OAuthIdTokenProvider";
 import {IdTokenPayload} from "../OAuthRestClient";
 import {IdTokenProviderLogin} from "./IdTokenProviderLogin";
 import {RestClientWithOAuth} from "../RestClientWithOAuth";
-import { IdTokenProviderUrl } from "./IdTokenProviderUrl";
+import {IdTokenProviderUrl} from "./IdTokenProviderUrl";
 import {IdTokenProviderStorage} from "./IdTokenProviderStorage";
 
 export class IdTokenProviderDefault implements OAuthIdTokenProvider {
@@ -35,10 +35,12 @@ export class IdTokenProviderDefault implements OAuthIdTokenProvider {
 						);
 				}
 			)
-			.then((t) => {
-				this.storage.saveIdTokenToLocalStorage(t);
-				return t;
-			});
+			.then(
+				(t) => {
+					this.storage.saveIdTokenToLocalStorage(t);
+					return t;
+				}
+			);
     }
 
 }

package/src/oauth/tokenprovider/IdTokenProviderStorage.ts

@@ -1,13 +1,14 @@
 import {OAuthIdTokenProvider} from "./OAuthIdTokenProvider";
 import {IdTokenPayload} from "../OAuthRestClient";
 import {JsonUtil} from "../../util";
+import {OAuthUtil} from "../../util/OAuthUtil";
 
 export class IdTokenProviderStorage implements OAuthIdTokenProvider {
 
 	key: string;
 
 	constructor(storageKey?: string) {
-		this.key = storageKey || 'id-token';
+		this.key = storageKey || '';
 	}
 
 	saveIdTokenToLocalStorage(token: IdTokenPayload | null) {
@@ -25,8 +26,8 @@ export class IdTokenProviderStorage implements OAuthIdTokenProvider {
 
 	getIdToken(): Promise<IdTokenPayload> {
         const token = this.getIdTokenFromLocalStorage();
-		if (token) return Promise.resolve(token);
-		return Promise.reject("No token found in storage!");
+		if (token && OAuthUtil.isValidToken(token)) return Promise.resolve(token);
+		return Promise.reject("No valid token found in storage!");
     }
 
 }

package/src/util/OAuthUtil.ts

@@ -0,0 +1,24 @@
+import {TokenResponsePayloadBase} from "../oauth";
+import {StringUtil} from "./StringUtil";
+
+export class OAuthUtil {
+
+	static isValidToken(token?: TokenResponsePayloadBase | null): boolean {
+		return token !== undefined && token !== null && StringUtil.notEmpty(token.token) && !OAuthUtil.isTokenExpired(token);
+	}
+
+	static isTokenExpired(token?: TokenResponsePayloadBase | null): boolean {
+		if (token === undefined || token === null) return false;
+		if (token.expires === undefined || token.expires === null) return false;
+		return (token.expires < new Date());
+	}
+
+	static isTokenReadyForRefresh(token?: TokenResponsePayloadBase | null): boolean {
+		if (token === undefined || token === null) return false;
+		if (OAuthUtil.isTokenExpired(token)) return false;
+		if (token.expires === undefined || token.expires === null) return false;
+		const middle = new Date((token.expires.getTime() + token.issuedAt.getTime()) / 2);
+		const now = new Date();
+		return (middle < now);
+	}
+}