@dehwyyy/auth 1.0.2 → 1.0.3

package/dist/guard/index.d.ts

@@ -7,8 +7,14 @@ export declare class Guards {
     private apiURL;
     private redirectBaseUrl;
     private redirectUriPrefix;
-    constructor(app: string, apiURL: string, redirectBaseUrl: string, redirectUriPrefix?: string);
-    private getLoginRedirectPath;
+    private onUserRetrieve?;
+    constructor(app: string, apiURL: string, redirectBaseUrl: string, redirectUriPrefix?: string, onUserRetrieve?: ((user: {
+        userId: string;
+        roles: string[];
+    }) => void) | undefined);
+    GetLoginRedirectPath(to: Route, from?: Route): {
+        redirect: () => string;
+    };
     Auth: (roles?: string[]) => (to: Route, from: Route) => Promise<string | true>;
 }
 export {};

package/dist/guard/index.js

@@ -10,48 +10,70 @@ export class Guards {
     apiURL;
     redirectBaseUrl;
     redirectUriPrefix;
-    constructor(app, apiURL, redirectBaseUrl, redirectUriPrefix = "") {
+    onUserRetrieve;
+    constructor(app, apiURL, redirectBaseUrl, redirectUriPrefix = "", onUserRetrieve) {
         this.app = app;
         this.apiURL = apiURL;
         this.redirectBaseUrl = redirectBaseUrl;
         this.redirectUriPrefix = redirectUriPrefix;
+        this.onUserRetrieve = onUserRetrieve;
     }
-    getLoginRedirectPath(to, from) {
-        const redirectUri = from.query['redirect_uri'] || encodeURIComponent(to.fullPath);
+    GetLoginRedirectPath(to, from) {
+        const redirectUri = from?.query['redirect_uri'] || encodeURIComponent(to.fullPath);
         const redirectPath = `${this.redirectBaseUrl}?redirect_uri=${this.redirectUriPrefix}${redirectUri}`;
-        return redirectPath;
+        return {
+            redirect: () => {
+                if (redirectPath.startsWith('http')) {
+                    window.location.href = redirectPath;
+                    return "";
+                }
+                return "";
+            }
+        };
     }
     Auth = (roles = []) => {
         return async (to, from) => {
-            const loginRedirect = this.getLoginRedirectPath(to, from);
-            const token = Storage.Get(StorageKey.ACCESS_TOKEN);
+            const loginRedirect = this.GetLoginRedirectPath(to, from);
+            let token = Storage.Get(StorageKey.ACCESS_TOKEN);
             if (!token) {
                 if (roles.length === 0)
                     return true;
-                console.warn('Access denied');
-                return loginRedirect;
+                // try to refresh
+                token = await GetAuthService(this.app, this.apiURL).Refresh();
+                if (token) {
+                    Storage.Set(StorageKey.ACCESS_TOKEN, token);
+                }
+                else {
+                    return loginRedirect.redirect();
+                }
             }
             const now = Date.now();
             if (meCache && meCache.expiresAt > now) {
                 const data = meCache.data;
                 if (arrayIntercept(data.roles, roles).length === 0) {
-                    return loginRedirect;
+                    return loginRedirect.redirect();
                 }
                 return true;
             }
-            const response = await GetAuthService(this.app, this.apiURL).Validate();
+            const response = await GetAuthService(this.app, this.apiURL).GetMe();
             if (!response) {
                 console.warn('Access denied');
-                return loginRedirect;
+                return loginRedirect.redirect();
             }
             meCache = { data: response, expiresAt: Date.now() + ME_CACHE_TTL_MS };
+            if (this.onUserRetrieve) {
+                this.onUserRetrieve({
+                    userId: response.userId,
+                    roles: response.roles,
+                });
+            }
             if (response.roles.length === 0) {
                 console.warn('No roles found');
-                return loginRedirect;
+                return loginRedirect.redirect();
             }
             if (arrayIntercept(response.roles, roles).length === 0) {
                 console.warn('Access denied');
-                return loginRedirect;
+                return loginRedirect.redirect();
             }
             return true;
         };

package/dist/index.d.ts

@@ -1,6 +1,14 @@
-interface ValidateResponse {
-    userId: string;
+interface GetMeResponse {
     roles: string[];
+    userId: string;
+    active: boolean;
+    info?: {
+        verified: boolean;
+        avatar?: string;
+        data?: Record<string, unknown>;
+        email?: string;
+        username?: string;
+    };
 }
 declare class AuthService {
     private app;
@@ -14,8 +22,10 @@ declare class AuthService {
      * @returns  `accessToken` -> refresh ok. `null` -> refresh failed
      **/
     private doRefresh;
-    Validate(): Promise<ValidateResponse | null>;
     WithAuthorizationToken(request: Request, token?: string | null): Request;
+    GetMe(verbose?: boolean): Promise<GetMeResponse | null>;
+    Logout(): Promise<boolean>;
+    Refresh(): Promise<string | null>;
     RefreshAndRetry(request: Request, response: Response): Promise<Response>;
 }
 export declare function GetAuthService(app: string, apiURL: string): AuthService;

package/dist/index.js

@@ -1,5 +1,6 @@
 import { getClient } from './client/client';
 import { Storage, StorageKey } from './client/storage/localStorage';
+;
 class AuthService {
     app;
     apiURL;
@@ -34,16 +35,26 @@ class AuthService {
         Storage.Delete(StorageKey.ACCESS_TOKEN);
         return null;
     }
-    // Validate token
-    async Validate() {
-        const token = Storage.Get(StorageKey.ACCESS_TOKEN);
+    WithAuthorizationToken(request, token = null) {
+        token ??= Storage.Get(StorageKey.ACCESS_TOKEN);
+        if (token) {
+            request.headers.set('Authorization', `Bearer ${token}`);
+        }
+        return request;
+    }
+    async GetMe(verbose = false) {
+        let token = Storage.Get(StorageKey.ACCESS_TOKEN);
         if (!token) {
-            return null;
+            token = await this.Refresh();
+            if (!token) {
+                return null;
+            }
         }
         const { response, data, error } = await this.getClient().GET('/auth/me', {
             params: {
                 query: {
                     app: this.app,
+                    verbose: verbose ? 'all' : 'none',
                 },
                 header: {
                     Authorization: `Bearer ${token}`,
@@ -61,14 +72,41 @@ class AuthService {
         return {
             userId: data.user_id,
             roles: data.roles || [],
+            active: data.active || false,
+            info: !data.info ? undefined : {
+                verified: data.info.verified || false,
+                username: data.info.username,
+                email: data.info.email,
+                avatar: data.info.avatar,
+                data: data.info.data,
+            },
         };
     }
-    WithAuthorizationToken(request, token = null) {
-        token ??= Storage.Get(StorageKey.ACCESS_TOKEN);
-        if (token) {
-            request.headers.set('Authorization', `Bearer ${token}`);
+    async Logout() {
+        Storage.Delete(StorageKey.ACCESS_TOKEN);
+        const { response, error } = await this.getClient().POST('/auth/logout');
+        if (error || !response.ok) {
+            console.error(error, response);
+            return false;
         }
-        return request;
+        return true;
+    }
+    async Refresh() {
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        this.refreshPromise = this.doRefresh();
+        let token = null;
+        try {
+            token = await this.refreshPromise;
+        }
+        catch (e) {
+            console.error(e);
+        }
+        finally {
+            this.refreshPromise = null;
+        }
+        return token;
     }
     async RefreshAndRetry(request, response) {
         if (!this.refreshPromise) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dehwyyy/auth",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "private": false,
   "description": "dehwyyy auth utilities",
   "type": "module",