@dehwyyy/auth 1.0.2 → 1.0.4

package/dist/client/client.d.ts

@@ -1,2 +1,2 @@
 import type { paths } from './schema';
-export declare const getClient: (app: string, baseUrl: string) => import("openapi-fetch").Client<paths, `${string}/${string}`>;
+export declare const getClient: (app: string, baseUrl: string, redirectBaseUrl: string, redirectUriPrefix?: string) => import("openapi-fetch").Client<paths, `${string}/${string}`>;

package/dist/client/client.js

@@ -1,13 +1,13 @@
 import createClient from 'openapi-fetch';
 import { Middleware } from './middleware';
 let client = null;
-export const getClient = (app, baseUrl) => {
+export const getClient = (app, baseUrl, redirectBaseUrl, redirectUriPrefix = "") => {
     if (!client) {
         client = createClient({
             baseUrl,
             credentials: 'include',
         });
-        const middleware = new Middleware(app, baseUrl);
+        const middleware = new Middleware(app, baseUrl, redirectBaseUrl, redirectUriPrefix);
         client.use(middleware.AuthorizationHeaderAttacher, middleware.TokenRefresher);
     }
     return client;

package/dist/client/middleware.d.ts

@@ -2,7 +2,9 @@ import type { Middleware as OpenAPIMiddleware } from 'openapi-fetch';
 export declare class Middleware {
     private app;
     private baseUrl;
-    constructor(app: string, baseUrl: string);
+    private redirectBaseUrl;
+    private redirectUriPrefix;
+    constructor(app: string, baseUrl: string, redirectBaseUrl: string, redirectUriPrefix?: string);
     get AuthorizationHeaderAttacher(): OpenAPIMiddleware;
     get TokenRefresher(): OpenAPIMiddleware;
 }

package/dist/client/middleware.js

@@ -2,15 +2,19 @@ import { GetAuthService } from '../index';
 export class Middleware {
     app;
     baseUrl;
-    constructor(app, baseUrl) {
+    redirectBaseUrl;
+    redirectUriPrefix;
+    constructor(app, baseUrl, redirectBaseUrl, redirectUriPrefix = "") {
         this.app = app;
         this.baseUrl = baseUrl;
+        this.redirectBaseUrl = redirectBaseUrl;
+        this.redirectUriPrefix = redirectUriPrefix;
     }
     get AuthorizationHeaderAttacher() {
-        const t = this;
+        const auth = GetAuthService(this.app, this.baseUrl, this.redirectBaseUrl, this.redirectUriPrefix);
         return {
             async onRequest({ request }) {
-                return GetAuthService(t.app, t.baseUrl).WithAuthorizationToken(request);
+                return auth.WithAuthorizationToken(request);
             },
         };
     }
@@ -21,7 +25,8 @@ export class Middleware {
                 if (response.status !== 401 || request.url.includes('/auth/refresh')) {
                     return response;
                 }
-                return GetAuthService(t.app, t.baseUrl).RefreshAndRetry(request, response);
+                const auth = GetAuthService(t.app, t.baseUrl, t.redirectBaseUrl, t.redirectUriPrefix);
+                return auth.RefreshAndRetry(request, response);
             },
         };
     }

package/dist/guard/index.d.ts

@@ -1,14 +1,11 @@
-interface Route {
-    query: Record<string, unknown>;
-    fullPath: string;
-}
-export declare class Guards {
-    private app;
-    private apiURL;
-    private redirectBaseUrl;
-    private redirectUriPrefix;
-    constructor(app: string, apiURL: string, redirectBaseUrl: string, redirectUriPrefix?: string);
-    private getLoginRedirectPath;
+import { GetAuthService } from '../index';
+import { Route } from '../types';
+export declare class Guard {
+    private getAuthService;
+    private onUserRetrieve?;
+    constructor(getAuthService: () => ReturnType<typeof GetAuthService>, onUserRetrieve?: ((user: {
+        userId: string;
+        roles: string[];
+    }) => void) | undefined);
     Auth: (roles?: string[]) => (to: Route, from: Route) => Promise<string | true>;
 }
-export {};

package/dist/guard/index.js

@@ -1,57 +1,60 @@
 import { Storage, StorageKey } from '../client/storage/localStorage';
-import { GetAuthService } from '../index';
 let meCache = null;
 const ME_CACHE_TTL_MS = 15 * 1000;
 function arrayIntercept(arr1, arr2) {
     return arr1.filter((item) => arr2.includes(item));
 }
-export class Guards {
-    app;
-    apiURL;
-    redirectBaseUrl;
-    redirectUriPrefix;
-    constructor(app, apiURL, redirectBaseUrl, redirectUriPrefix = "") {
-        this.app = app;
-        this.apiURL = apiURL;
-        this.redirectBaseUrl = redirectBaseUrl;
-        this.redirectUriPrefix = redirectUriPrefix;
-    }
-    getLoginRedirectPath(to, from) {
-        const redirectUri = from.query['redirect_uri'] || encodeURIComponent(to.fullPath);
-        const redirectPath = `${this.redirectBaseUrl}?redirect_uri=${this.redirectUriPrefix}${redirectUri}`;
-        return redirectPath;
+export class Guard {
+    getAuthService;
+    onUserRetrieve;
+    constructor(getAuthService, onUserRetrieve) {
+        this.getAuthService = getAuthService;
+        this.onUserRetrieve = onUserRetrieve;
     }
     Auth = (roles = []) => {
         return async (to, from) => {
-            const loginRedirect = this.getLoginRedirectPath(to, from);
-            const token = Storage.Get(StorageKey.ACCESS_TOKEN);
+            const auth = this.getAuthService();
+            const loginRedirect = auth.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 auth.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 auth.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,22 +1,26 @@
-interface ValidateResponse {
-    userId: string;
-    roles: string[];
-}
+import { GetMeResponse, Route } from './types';
 declare class AuthService {
     private app;
     private apiURL;
+    private redirectBaseUrl;
+    private redirectUriPrefix;
     private refreshPromise;
-    constructor(app: string, apiURL: string);
-    withApp(app: string): this;
+    constructor(app: string, apiURL: string, redirectBaseUrl: string, redirectUriPrefix?: string);
     private getClient;
     /**
      * @description Refresh access token
      * @returns  `accessToken` -> refresh ok. `null` -> refresh failed
      **/
     private doRefresh;
-    Validate(): Promise<ValidateResponse | null>;
+    withApp(app: string): this;
     WithAuthorizationToken(request: Request, token?: string | null): Request;
+    GetLoginRedirectPath(to: Route, from?: Route): {
+        redirect: () => string;
+    };
+    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;
+export declare function GetAuthService(app: string, apiURL: string, redirectBaseUrl: string, redirectUriPrefix: string): AuthService;
 export {};

package/dist/index.js

@@ -3,18 +3,18 @@ import { Storage, StorageKey } from './client/storage/localStorage';
 class AuthService {
     app;
     apiURL;
+    redirectBaseUrl;
+    redirectUriPrefix;
     // теперь обещание возвращает сам новый токен или null
     refreshPromise = null;
-    constructor(app, apiURL) {
+    constructor(app, apiURL, redirectBaseUrl, redirectUriPrefix = "") {
         this.app = app;
         this.apiURL = apiURL;
-    }
-    withApp(app) {
-        this.app = app;
-        return this;
+        this.redirectBaseUrl = redirectBaseUrl;
+        this.redirectUriPrefix = redirectUriPrefix;
     }
     getClient() {
-        return getClient(this.app, this.apiURL);
+        return getClient(this.app, this.apiURL, this.redirectBaseUrl, this.redirectUriPrefix);
     }
     /**
      * @description Refresh access token
@@ -34,16 +34,43 @@ class AuthService {
         Storage.Delete(StorageKey.ACCESS_TOKEN);
         return null;
     }
-    // Validate token
-    async Validate() {
-        const token = Storage.Get(StorageKey.ACCESS_TOKEN);
+    withApp(app) {
+        this.app = app;
+        return this;
+    }
+    WithAuthorizationToken(request, token = null) {
+        token ??= Storage.Get(StorageKey.ACCESS_TOKEN);
+        if (token) {
+            request.headers.set('Authorization', `Bearer ${token}`);
+        }
+        return request;
+    }
+    GetLoginRedirectPath(to, from) {
+        const redirectUri = from?.query['redirect_uri'] || encodeURIComponent(to.fullPath);
+        const redirectPath = `${this.redirectBaseUrl}?redirect_uri=${this.redirectUriPrefix}${redirectUri}`;
+        return {
+            redirect: () => {
+                if (redirectPath.startsWith('http')) {
+                    window.location.href = redirectPath;
+                    return "";
+                }
+                return redirectPath;
+            }
+        };
+    }
+    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 +88,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) {
@@ -98,9 +152,9 @@ class AuthService {
     }
 }
 let auth = null;
-export function GetAuthService(app, apiURL) {
+export function GetAuthService(app, apiURL, redirectBaseUrl, redirectUriPrefix) {
     if (!auth) {
-        auth = new AuthService(app, apiURL);
+        auth = new AuthService(app, apiURL, redirectBaseUrl, redirectUriPrefix);
     }
     return auth.withApp(app);
 }

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+export interface GetMeResponse {
+    roles: string[];
+    userId: string;
+    active: boolean;
+    info?: {
+        verified: boolean;
+        avatar?: string;
+        data?: Record<string, unknown>;
+        email?: string;
+        username?: string;
+    };
+}
+export interface Route {
+    query: Record<string, unknown>;
+    fullPath: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+;
+export {};

package/package.json

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