@dehwyyy/auth 1.0.3 → 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,20 +1,11 @@
-interface Route {
-    query: Record<string, unknown>;
-    fullPath: string;
-}
-export declare class Guards {
-    private app;
-    private apiURL;
-    private redirectBaseUrl;
-    private redirectUriPrefix;
+import { GetAuthService } from '../index';
+import { Route } from '../types';
+export declare class Guard {
+    private getAuthService;
     private onUserRetrieve?;
-    constructor(app: string, apiURL: string, redirectBaseUrl: string, redirectUriPrefix?: string, onUserRetrieve?: ((user: {
+    constructor(getAuthService: () => ReturnType<typeof GetAuthService>, 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

@@ -1,45 +1,26 @@
 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;
+export class Guard {
+    getAuthService;
     onUserRetrieve;
-    constructor(app, apiURL, redirectBaseUrl, redirectUriPrefix = "", onUserRetrieve) {
-        this.app = app;
-        this.apiURL = apiURL;
-        this.redirectBaseUrl = redirectBaseUrl;
-        this.redirectUriPrefix = redirectUriPrefix;
+    constructor(getAuthService, onUserRetrieve) {
+        this.getAuthService = getAuthService;
         this.onUserRetrieve = onUserRetrieve;
     }
-    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 "";
-            }
-        };
-    }
     Auth = (roles = []) => {
         return async (to, from) => {
-            const loginRedirect = this.GetLoginRedirectPath(to, from);
+            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;
                 // try to refresh
-                token = await GetAuthService(this.app, this.apiURL).Refresh();
+                token = await auth.Refresh();
                 if (token) {
                     Storage.Set(StorageKey.ACCESS_TOKEN, token);
                 }
@@ -55,7 +36,7 @@ export class Guards {
                 }
                 return true;
             }
-            const response = await GetAuthService(this.app, this.apiURL).GetMe();
+            const response = await auth.GetMe();
             if (!response) {
                 console.warn('Access denied');
                 return loginRedirect.redirect();

package/dist/index.d.ts

@@ -1,32 +1,26 @@
-interface GetMeResponse {
-    roles: string[];
-    userId: string;
-    active: boolean;
-    info?: {
-        verified: boolean;
-        avatar?: string;
-        data?: Record<string, unknown>;
-        email?: string;
-        username?: 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;
+    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

@@ -1,21 +1,20 @@
 import { getClient } from './client/client';
 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
@@ -35,6 +34,10 @@ class AuthService {
         Storage.Delete(StorageKey.ACCESS_TOKEN);
         return null;
     }
+    withApp(app) {
+        this.app = app;
+        return this;
+    }
     WithAuthorizationToken(request, token = null) {
         token ??= Storage.Get(StorageKey.ACCESS_TOKEN);
         if (token) {
@@ -42,6 +45,19 @@ class AuthService {
         }
         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) {
@@ -136,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.3",
+  "version": "1.0.4",
   "private": false,
   "description": "dehwyyy auth utilities",
   "type": "module",