@thzero/library_client_firebase 0.17.6 → 0.17.8

package/boot/starter.js

@@ -1,48 +1,50 @@
-import { initializeApp } from 'firebase/app';
-import { getAuth } from "firebase/auth";
-import { getAnalytics } from "firebase/analytics";
+// import { initializeApp } from 'firebase/app';
+// import { getAuth } from "firebase/auth";
+// import { getAnalytics } from "firebase/analytics";
 
 import LibraryClientConstants from '@thzero/library_client/constants';
 
 import LibrartyClientUtility from '@thzero/library_client/utility/index';
 
-import config from 'local-config';
+// import config from 'local-config';
 
 // export default async ({
-export default (setup) => {
-	const configExternal = config.external;
-	if (!configExternal)
-		throw Error('Invalid external config.');
-	const configFirebase = configExternal.firebase;
-	if (!configFirebase)
-		throw Error('Invalid firebase config.');
-	initializeApp(configFirebase);
-	if (configFirebase.measurementId)
-		getAnalytics();
-
-	let outsideResolve;
-	let outsideReject;
-	const promiseAuth = new Promise(function(resolve, reject) {
-		outsideResolve = resolve;
-		outsideReject = reject;
-	});
-
-	const firebaseAuth = getAuth();
-	// eslint-disable-next-line
-	let init = false;
-	firebaseAuth.onAuthStateChanged(async function(user) {
-		const auth = LibrartyClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_AUTH);
-		await auth.onAuthStateChanged(user);
-		if (!init) {
-			init = true;
-			outsideResolve(true);
-			return;
-		}
-
-		outsideReject();
-	});
-
-	setup();
-
-	return promiseAuth;
+export default (router) => {
+	const auth = LibrartyClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_AUTH);
+	return auth.initialize(router);
+	// const configExternal = config.external;
+	// if (!configExternal)
+	// 	throw Error('Invalid external config.');
+	// const configFirebase = configExternal.firebase;
+	// if (!configFirebase)
+	// 	throw Error('Invalid firebase config.');
+	// initializeApp(configFirebase);
+	// if (configFirebase.measurementId)
+	// 	getAnalytics();
+
+	// let outsideResolve;
+	// let outsideReject;
+	// const promiseAuth = new Promise(function(resolve, reject) {
+	// 	outsideResolve = resolve;
+	// 	outsideReject = reject;
+	// });
+
+	// const firebaseAuth = getAuth();
+	// // eslint-disable-next-line
+	// let init = false;
+	// firebaseAuth.onAuthStateChanged(async function(user) {
+	// 	const auth = LibrartyClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_AUTH);
+	// 	await auth.onAuthStateChanged(user);
+	// 	if (!init) {
+	// 		init = true;
+	// 		outsideResolve(true);
+	// 		return;
+	// 	}
+
+	// 	outsideReject();
+	// });
+
+	// setup();
+
+	// return promiseAuth;
 };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@thzero/library_client_firebase",
-  "version": "0.17.6",
+  "version": "0.17.8",
   "version_major": 0,
   "version_minor": 17,
-  "version_patch": 6,
-  "version_date": "03/19/2023",
+  "version_patch": 8,
+  "version_date": "04/20/2023",
   "author": "thZero",
   "license": "MIT",
   "repository": {

package/service/index.js

@@ -1,5 +1,6 @@
-// import firebase from 'firebase/app';
-// import 'firebase/auth';
+import { initializeApp } from 'firebase/app';
+// import { getAuth } from "firebase/auth";
+import { getAnalytics } from "firebase/analytics";
 import { getAuth, signInWithPopup, GoogleAuthProvider } from "firebase/auth";
 
 import LibraryClientConstants from '@thzero/library_client/constants';
@@ -18,6 +19,12 @@ class FirebaseAuthService extends UserAuthService {
 		this._serviceRouter = null;
 	}
 
+	async init(injector) {
+		await super.init(injector);
+
+		this._serviceRouter = this._injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_ROUTER);
+	}
+
 	async deleteUser(correlationId) {
 		try {
 			const user = await getAuth().currentUser;
@@ -33,28 +40,56 @@ class FirebaseAuthService extends UserAuthService {
 		}
 	}
 
-	async init(injector) {
-		await super.init(injector);
-
-		this._serviceRouter = this._injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_ROUTER);
-	}
-
 	get externalUser() {
 		const user = getAuth().currentUser;
 		this._logger.debug('FirebaseAuthService', 'tokenUser', 'user', user, LibraryCommonUtility.generateId());
 		return user;
 	}
 
+	async initialize(router) {
+		const configExternal = this._config.getExternal();
+		if (!configExternal)
+			throw Error('Invalid external config.');
+		const configFirebase = configExternal.firebase;
+		if (!configFirebase)
+			throw Error('Invalid firebase config.');
+		initializeApp(configFirebase);
+		if (configFirebase.measurementId)
+			getAnalytics();
+
+		let outsideResolve;
+		let outsideReject;
+		const promiseAuth = new Promise(function(resolve, reject) {
+			outsideResolve = resolve;
+			outsideReject = reject;
+		});
+
+		const self = this;
+		const firebaseAuth = getAuth();
+		// eslint-disable-next-line
+		let init = false;
+		firebaseAuth.onAuthStateChanged(async function(user) {
+			// const auth = LibrartyClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_AUTH);
+			// await auth.onAuthStateChanged(user);
+			await self.onAuthStateChanged(user);
+			if (!init) {
+				init = true;
+				outsideResolve(true);
+				return;
+			}
+
+			outsideReject();
+		});
+
+		return promiseAuth;
+	}
+
 	get isAuthenticated() {
 		const user = getAuth().currentUser;
 		this._logger.debug('FirebaseAuthService', 'isAuthenticated', 'user', user);
 		return user !== null;
 	}
 
-	get token() {
-		return this._serviceUser.token;
-	}
-
 	async onAuthStateChanged(user) {
 		const correlationId = LibraryCommonUtility.correlationId();
 		try {
@@ -86,6 +121,149 @@ class FirebaseAuthService extends UserAuthService {
 		// }
 	}
 
+	async refreshToken(correlationId, user, forceRefresh) {
+		forceRefresh = forceRefresh !== null ? forceRefresh : false;
+
+		try {
+			this._logger.debug('FirebaseAuthService', 'refreshToken', 'user', user, correlationId);
+			if (!user) {
+				await this._serviceUser.setTokenResult(correlationId, null);
+				await this._serviceUser.setClaims(correlationId, null);
+				this.announceToken(correlationId, user, null);
+
+				return;
+			}
+
+			this._logger.debug('FirebaseAuthService', 'refreshToken', 'forceRefresh', forceRefresh, correlationId);
+			const currentUser = await getAuth().currentUser;
+			this._logger.debug('FirebaseAuthService', 'refreshToken', 'currentUser', currentUser, correlationId);
+			if (!currentUser)
+				return;
+
+			const tokenResult = await currentUser.getIdTokenResult(forceRefresh);
+			if (tokenResult) {
+				await this._serviceUser.setTokenResult(correlationId, tokenResult);
+				const token = tokenResult.token;
+				let claims = token != null ? tokenResult.claims : null;
+				this._logger.debug('FirebaseAuthService', 'refreshToken', 'claims', claims, correlationId);
+				claims = claims != null ? claims.custom : null;
+				this._logger.debug('FirebaseAuthService', 'refreshToken', 'claims.custom', claims, correlationId);
+				await this._serviceUser.setClaims(correlationId, claims);
+
+				this.announceToken(correlationId, user, token);
+
+				const expired = LibraryCommonUtility.getDateParse(tokenResult.expirationTime);
+				const now = LibraryCommonUtility.getDate();
+				const diff = expired.diff(now);
+				const min = 5 * 60 * 1000;
+				if (diff <= min) {
+					await this.refreshToken(correlationId, getAuth().currentUser, true).then();
+					return;
+				}
+
+				if (this._polling)
+					clearInterval(this._polling);
+
+				const self = this;
+				this._polling = setInterval(async () => {
+					await self.refreshToken(correlationId, self.user, true).then();
+				}, diff); // 60 * 1000)
+			}
+			else {
+				await this._serviceUser.setTokenResult(correlationId, null);
+				await this._serviceUser.setClaims(correlationId, null);
+
+				this.announceToken(correlationId, user, token);
+
+				if (this._polling)
+					clearInterval(this._polling);
+			}
+		}
+		catch (err) {
+			this._logger.exception('FirebaseAuthService', 'refreshToken', err, correlationId);
+			throw err;
+		}
+	}
+
+	async resolveAuthorization(correlationId, requiresAuthRoles, requiresAuthLogical) {
+		// const serviceAuth = LibraryClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_AUTH);
+		// const serviceLogger = LibraryClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_LOGGER);
+		// const serviceSecurity = LibraryClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_SECURITY);
+		// const serviceStore = LibraryClientUtility.$injector.getService(LibraryClientConstants.InjectorKeys.SERVICE_STORE);
+		this._serviceLogger.info2('requiresAuth');
+		let isLoggedIn = this.isAuthenticated;
+		this._serviceLogger.info2('authorization.isLoggedIn', isLoggedIn);
+		console.log('authorization.isLoggedIn', isLoggedIn);
+		if (!isLoggedIn) {
+			// Briefly wait for authentication to settle...
+			let i = 0;
+			while (await this.sleep(150)) {
+				if (this._serviceStore.userAuthCompleted) {
+					this._serviceLogger.info2('authorization.userAuthCompleted', userAuthCompleted);
+					console.log('authorization.userAuthCompleted', userAuthCompleted);
+					break;
+				}
+				i++;
+				this._serviceLogger.info2('waiting... ' + i);
+				if (i > 5) {
+					this._serviceLogger.warn2('authorization.userAuthCompleted failed');
+					break;
+				}
+			}
+			const isLoggedInAuthCompleted = this.isAuthenticated;
+			this._serviceLogger.info2('authorization.isLoggedIn.userAuthCompleted', isLoggedInAuthCompleted);
+			console.log('authorization.isLoggedIn.userAuthCompleted', isLoggedInAuthCompleted);
+			isLoggedIn = isLoggedInAuthCompleted;
+		}
+		this._serviceLogger.info2('authorization.isLoggedIn.final', isLoggedIn);
+		console.log('authorization.isLoggedIn.final', isLoggedIn);
+		if (!isLoggedIn) {
+			this._serviceLogger.warn2('authorization.isLoggedIn - failed');
+			console.log('authorization.isLoggedIn - failed');
+			// LibraryClientUtility.$EventBus.on('auth-refresh', (user) => {
+			//	 this._serviceLogger.debug('auth-refresh', user)
+			//	 this._serviceLogger.debug('middleware', 'auth-refresh', null, user, correlationId);
+			//	 next()
+			// })
+			// return
+			return false;
+		}
+
+		this._serviceLogger.info2('authorization.isLoggedIn - success');
+		console.log('authorization.isLoggedIn - success');
+
+		const user = this._serviceStore.user;
+		let success = true;
+		this._serviceLogger.info2('authorization.requiresAuthRoles', requiresAuthRoles);
+		console.log('authorization.requiresAuthRoles', requiresAuthRoles);
+		this._serviceLogger.info2('authorization.requiresAuthLogical', requiresAuthLogical);
+		console.log('authorization.requiresAuthLogical', requiresAuthLogical);
+
+		if (requiresAuthRoles) {
+			success = await this._serviceSecurity.authorizationCheckRoles(correlationId, user, roles, record.meta.requiresAuthLogical);
+			this._serviceLogger.info2('authorization.roles.success', success);
+			console.log('authorization.roles.success', success);
+		}
+
+		this._serviceLogger.debug('middleware', 'authorization', 'success', success, correlationId);
+		console.log('authorization.roles.success', success);
+		this._serviceLogger.info2('authorization.roles.success', success);
+		if (!success) {
+			this._serviceLogger.warn2('authorization.roles - failed');
+			console.log('authorization.roles - failed');
+			LibraryClientUtility.$navRouter.push('/', null, () => {
+				// LibraryClientUtility.$navRouter.push('/')
+				// window.location.href = '/'
+			});
+			return false;
+		}
+
+		this._serviceLogger.info2('authorization.roles - success');
+		console.log('authorization.roles - success');
+
+		return true;
+	}
+
 	async signIn(correlationId) {
 		if (this.isAuthenticated)
 			return false;
@@ -168,6 +346,16 @@ class FirebaseAuthService extends UserAuthService {
 		}
 	}
 
+	sleep(ms) {
+	  return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	  });
+	}
+
+	get token() {
+		return this._serviceUser.token;
+	}
+
 	// async token(forceRefresh) {
 	// 	if (!forceRefresh)
 	// 		forceRefresh = false
@@ -181,70 +369,6 @@ class FirebaseAuthService extends UserAuthService {
 	// 	return this.refreshToken'FirebaseAuthService', 'token', user, forceRefresh)
 	// }
 
-	async refreshToken(correlationId, user, forceRefresh) {
-		forceRefresh = forceRefresh !== null ? forceRefresh : false;
-
-		try {
-			this._logger.debug('FirebaseAuthService', 'refreshToken', 'user', user, correlationId);
-			if (!user) {
-				await this._serviceUser.setTokenResult(correlationId, null);
-				await this._serviceUser.setClaims(correlationId, null);
-				this.announceToken(correlationId, user, null);
-
-				return;
-			}
-
-			this._logger.debug('FirebaseAuthService', 'refreshToken', 'forceRefresh', forceRefresh, correlationId);
-			const currentUser = await getAuth().currentUser;
-			this._logger.debug('FirebaseAuthService', 'refreshToken', 'currentUser', currentUser, correlationId);
-			if (!currentUser)
-				return;
-
-			const tokenResult = await currentUser.getIdTokenResult(forceRefresh);
-			if (tokenResult) {
-				await this._serviceUser.setTokenResult(correlationId, tokenResult);
-				const token = tokenResult.token;
-				let claims = token != null ? tokenResult.claims : null;
-				this._logger.debug('FirebaseAuthService', 'refreshToken', 'claims', claims, correlationId);
-				claims = claims != null ? claims.custom : null;
-				this._logger.debug('FirebaseAuthService', 'refreshToken', 'claims.custom', claims, correlationId);
-				await this._serviceUser.setClaims(correlationId, claims);
-
-				this.announceToken(correlationId, user, token);
-
-				const expired = LibraryCommonUtility.getDateParse(tokenResult.expirationTime);
-				const now = LibraryCommonUtility.getDate();
-				const diff = expired.diff(now);
-				const min = 5 * 60 * 1000;
-				if (diff <= min) {
-					await this.refreshToken(correlationId, getAuth().currentUser, true).then();
-					return;
-				}
-
-				if (this._polling)
-					clearInterval(this._polling);
-
-				const self = this;
-				this._polling = setInterval(async () => {
-					await self.refreshToken(correlationId, self.user, true).then();
-				}, diff); // 60 * 1000)
-			}
-			else {
-				await this._serviceUser.setTokenResult(correlationId, null);
-				await this._serviceUser.setClaims(correlationId, null);
-
-				this.announceToken(correlationId, user, token);
-
-				if (this._polling)
-					clearInterval(this._polling);
-			}
-		}
-		catch (err) {
-			this._logger.exception('FirebaseAuthService', 'refreshToken', err, correlationId);
-			throw err;
-		}
-	}
-
 	async updateExternalUser(correlationId, user) {
 		// if (this._lock)
 		// 	return