v3.0.3 (#83)

* feature & fix: response error interceptor

* function edge-cases

* feature: redirects as functions

* fix: lint

* update: readme

* update: readme

Author: Denoder

README.md

@@ -40,6 +40,9 @@ export default defineNuxtConfig({
 
 ```
 
+## Documentation
+I do not have the resources to host a dedicated documentation page, however I have been making updates to a [Stackblitz](https://stackblitz.com/edit/github-nufjhw-1bec1b) container so you may check there
+
 ## Changes 
 
 The module now uses '@nuxt-alt/http' to function, that module extends ohmyfetch. Please note that if you were using `data` to post data, you now need to use `body` since this is what `ohmyfetch` uses. If you intend to use ssr, please consider using the `@nuxt-alt/proxy` module.
@@ -138,6 +141,24 @@ The default cookie storage options.
 
 The type of redirection strategy you want to use, `storage` utilizng localStorage for redirects, `query` utilizing the route query parameters.
 
+### `resetOnResponseError`
+
+- Type: `Boolean | Function`
+- Default: `false`
+
+When enabled it will reset when there's a 401 error in any of the responses. You are able to turn this into a function to handle this yourself:
+```ts
+auth: {
+    //... module options
+    resetOnResponseError: (error, auth, scheme) => {
+       if (error.response.status === 401) {
+           scheme.reset?.()
+           auth.redirect('login')
+       }
+   },
+}
+```
+
 ## TypeScript (2.6.0+)
 The user information can be edited like so for TypeScript:
 ```ts

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nuxt-alt/auth",
-    "version": "3.0.2",
+    "version": "3.0.3",
     "description": "An alternative module to @nuxtjs/auth",
     "homepage": "https://github.com/nuxt-alt/auth",
     "author": "Denoder",

src/options.ts

@@ -10,6 +10,8 @@ export const moduleDefaults: ModuleOptions = {
 
     resetOnError: false,
 
+    resetOnResponseError: false,
+
     ignoreExceptions: false,
 
     // -- Authorization --

src/plugin.ts

@@ -27,11 +27,41 @@ import { defu } from 'defu';
 ${options.schemeImports.map((i) => `import { ${i.name}${i.name !== i.as ? ' as ' + i.as : ''} } from '${i.from}'`).join('\n')}
 
 // Options
-const options = ${JSON.stringify(options.options, null, 4)}
+let options = ${JSON.stringify(options.options, converter, 4)}
+
+function parse(config) {
+    const functionRegex1 = "/\\b\\w+\\s*\\((.*?)\\)\\s*\\{|function\\s*\\((.*?)\\)\\s*\\{|(\\w+)\\s*=>|\\([^)]*\\)\\s*=>|\\basync\\s+function\\b/";
+    const functionRegex2 = "/\\b\\w+(\\s)+\\((.*?)\\)\\s*\\{/";
+
+    for (let prop in config) {
+        if (typeof config[prop] === 'string' && (new RegExp(functionRegex1).test(config[prop]) || new RegExp(functionRegex2).test(config[prop]))) {
+            const paramsStart = config[prop].indexOf('(');
+            const paramsEnd = config[prop].indexOf(')');
+            const functionParams = config[prop].substring(paramsStart + 1, paramsEnd).split(',').map(item => item.trim());
+
+            let functionBody;
+            if (config[prop].includes('{')) {  
+                const functionBodyStart = config[prop].indexOf('{');
+                const functionBodyEnd = config[prop].lastIndexOf('}');
+                functionBody = config[prop].substring(functionBodyStart + 1, functionBodyEnd);
+                config[prop] = new Function('return function(' + functionParams.join(',') + '){' + functionBody + '}')();
+            } else {
+                functionBody = config[prop].substring(paramsEnd + 1).trim();
+                if (functionBody.startsWith('=>')) functionBody = functionBody.slice(2).trim();
+                config[prop] = new Function('return function(' + functionParams.join(',') + '){return ' + functionBody + '}')();
+            }
+        } else if (typeof config[prop] === 'object' && config[prop] !== null) {
+            parse(config[prop]);
+        }
+    }
+
+    return config
+}
 
 export default defineNuxtPlugin({
     name: 'nuxt-alt:auth',
     async setup(nuxtApp) {
+        options = parse(options)
         // Create a new Auth instance
         const auth = new Auth(nuxtApp, options)
 
@@ -60,3 +90,11 @@ export default defineNuxtPlugin({
     }
 })`
 }
+
+function converter(key: string, val: any) {
+    if (val && val.constructor === RegExp || typeof val === 'function') {
+        return String(val)
+    }
+
+    return val
+}

src/runtime/core/auth.ts

@@ -27,11 +27,10 @@ export class Auth {
             this.ctx.hook('i18n:localeSwitched', () => {
                 this.#transformRedirect(this.options.redirect);
             })
-
-            // Apply to initial options
-            this.#transformRedirect(options.redirect);
         }
 
+        // Apply to initial options
+        this.#transformRedirect(options.redirect);
         this.options = options;
 
         // Storage & State
@@ -57,7 +56,13 @@ export class Auth {
             if (typeof value === 'string' && typeof this.ctx.$localePath === 'function') {
                 redirects[key as keyof typeof this.options.redirect] = this.ctx.$localePath(value);
             }
+
+            if (typeof value === 'function') {
+                redirects[key as keyof typeof this.options.redirect] = value(this, typeof this.ctx.$localePath === 'function' ? this.ctx.$localePath as Function : undefined)
+            }
         }
+
+        return redirects;
     }
 
     getStrategy(throwException = true): Scheme {
@@ -377,7 +382,7 @@ export class Auth {
             return;
         }
 
-        let to: string = this.options.redirect[name as keyof typeof this.options.redirect];
+        let to = this.options.redirect[name as keyof typeof this.options.redirect] as string;
 
         if (!to) {
             return;

src/runtime/core/middleware.ts

@@ -28,7 +28,7 @@ export default defineNuxtRouteMiddleware(async (to, from) => {
         const { tokenExpired, refreshTokenExpired, isRefreshable } = auth.check(true);
 
         // -- Authorized --
-        if (!login || insidePage(login) || pageIsInGuestMode) {
+        if (!login || insidePage(login as string) || pageIsInGuestMode) {
             return auth.redirect('home', to)
         }
 
@@ -58,7 +58,7 @@ export default defineNuxtRouteMiddleware(async (to, from) => {
     // -- Guest --
     // (Those passing `callback` at runtime need to mark their callback component
     // with `auth: false` to avoid an unnecessary redirect from callback to login)
-    else if (!pageIsInGuestMode && (!callback || !insidePage(callback))) {
+    else if (!pageIsInGuestMode && (!callback || !insidePage(callback as string))) {
         return auth.redirect('login', to);
     }
 });

src/runtime/inc/request-handler.ts

@@ -1,16 +1,21 @@
 import type { TokenableScheme, RefreshableScheme } from '../../types';
+import type { Auth } from '..'
 import { ExpiredAuthSessionError } from './expired-auth-session-error';
 import { FetchInstance, type FetchConfig } from '@refactorjs/ofetch';
 
 export class RequestHandler {
     scheme: TokenableScheme | RefreshableScheme;
+    auth: Auth;
     http: FetchInstance;
-    interceptor: number | undefined | null;
+    requestInterceptor: number | undefined | null;
+    responseInterceptor: number | undefined | null;
 
-    constructor(scheme: TokenableScheme | RefreshableScheme, http: FetchInstance) {
+    constructor(scheme: TokenableScheme | RefreshableScheme, http: FetchInstance, auth: Auth) {
         this.scheme = scheme;
         this.http = http;
-        this.interceptor = null;
+        this.auth = auth;
+        this.requestInterceptor = null;
+        this.responseInterceptor = null;
     }
 
     setHeader(token: string): void {
@@ -28,7 +33,7 @@ export class RequestHandler {
     }
 
     initializeRequestInterceptor(refreshEndpoint?: string | Request): void {
-        this.interceptor = this.http.interceptors.request.use(
+        this.requestInterceptor = this.http.interceptors.request.use(
             async (config: FetchConfig) => {
                 // Don't intercept refresh token requests
                 if ((this.scheme.options.token && !this.#needToken(config)) || config.url === refreshEndpoint) {
@@ -83,12 +88,26 @@ export class RequestHandler {
                 return this.#getUpdatedRequestConfig(config, token ? token.get() : false);
             }
         );
+        this.responseInterceptor = this.http.interceptors.response.use(
+            res => res,
+            error => {
+                if (typeof this.auth.options.resetOnResponseError === 'function') {
+                    this.auth.options.resetOnResponseError(error, this.auth, this.scheme)
+                }
+                else if (this.auth.options.resetOnResponseError && error.response.status === 401) {
+                    this.scheme.reset?.()
+                    throw new ExpiredAuthSessionError();
+                }
+            }
+        );
     }
 
     reset(): void {
         // Eject request interceptor
-        this.http.interceptors.request.eject(this.interceptor as number);
-        this.interceptor = null;
+        this.http.interceptors.request.eject(this.requestInterceptor as number);
+        this.http.interceptors.response.eject(this.responseInterceptor as number);
+        this.requestInterceptor = null;
+        this.responseInterceptor = null;
     }
 
     #needToken(config: FetchConfig): boolean {

src/runtime/schemes/local.ts

@@ -65,7 +65,7 @@ export class LocalScheme<OptionsT extends LocalSchemeOptions = LocalSchemeOption
         this.token = new Token(this, this.$auth.$storage);
 
         // Initialize Request Interceptor
-        this.requestHandler = new RequestHandler(this, this.$auth.ctx.$http);
+        this.requestHandler = new RequestHandler(this, this.$auth.ctx.$http, $auth);
     }
 
     check(checkStatus = false): SchemeCheck {
@@ -151,7 +151,7 @@ export class LocalScheme<OptionsT extends LocalSchemeOptions = LocalSchemeOption
         this.updateTokens(response);
 
         // Initialize request interceptor if not initialized
-        if (!this.requestHandler.interceptor) {
+        if (!this.requestHandler.requestInterceptor) {
             this.initializeRequestInterceptor();
         }
 

src/runtime/schemes/oauth2.ts

@@ -106,7 +106,7 @@ export class Oauth2Scheme<OptionsT extends Oauth2SchemeOptions = Oauth2SchemeOpt
         this.refreshController = new RefreshController(this);
 
         // Initialize Request Handler
-        this.requestHandler = new RequestHandler(this, this.$auth.ctx.$http);
+        this.requestHandler = new RequestHandler(this, this.$auth.ctx.$http, $auth);
 
         // Initialize Client Window Reference
         this.#clientWindowReference = null;
@@ -123,7 +123,7 @@ export class Oauth2Scheme<OptionsT extends Oauth2SchemeOptions = Oauth2SchemeOpt
     }
 
     protected get logoutRedirectURI(): string {
-        return (this.options.logoutRedirectUri || joinURL(requrl(this.req), this.$auth.options.redirect.logout));
+        return (this.options.logoutRedirectUri || joinURL(requrl(this.req), this.$auth.options.redirect.logout as string));
     }
 
     check(checkStatus = false): SchemeCheck {
@@ -350,7 +350,7 @@ export class Oauth2Scheme<OptionsT extends Oauth2SchemeOptions = Oauth2SchemeOpt
         const route = (this.$auth.ctx.$router as Router).currentRoute.value
 
         // Handle callback only for specified route
-        if (this.$auth.options.redirect && normalizePath(route.path) !== normalizePath(this.$auth.options.redirect.callback)) {
+        if (this.$auth.options.redirect && normalizePath(route.path) !== normalizePath(this.$auth.options.redirect.callback as string)) {
             return;
         }
 

src/runtime/schemes/openIDConnect.ts

@@ -178,7 +178,7 @@ export class OpenIDConnectScheme<OptionsT extends OpenIDConnectSchemeOptions = O
         const route = (this.$auth.ctx.$router as Router).currentRoute.value;
 
         // Handle callback only for specified route
-        if (this.$auth.options.redirect && normalizePath(route.path) !== normalizePath(this.$auth.options.redirect.callback)) {
+        if (this.$auth.options.redirect && normalizePath(route.path) !== normalizePath(this.$auth.options.redirect.callback as string)) {
             return;
         }
 

src/types/options.d.ts

@@ -1,7 +1,8 @@
 import type { Strategy } from './strategy';
 import type { NuxtPlugin } from '@nuxt/schema';
-import type { AuthState } from './index';
+import type { AuthState, RefreshableScheme, TokenableScheme } from './index';
 import type { CookieSerializeOptions } from 'cookie-es';
+import type { Auth } from '../runtime'
 
 export interface ModuleOptions {
     globalMiddleware?: boolean;
@@ -10,6 +11,7 @@ export interface ModuleOptions {
     strategies?: Record<string, Strategy>;
     ignoreExceptions: boolean;
     resetOnError: boolean | ((...args: any[]) => boolean);
+    resetOnResponseError: boolean | ((error: any, auth: Auth, scheme: TokenableScheme | RefreshableScheme) => void);
     defaultStrategy: string | undefined;
     watchLoggedIn: boolean;
     rewriteRedirects: boolean;
@@ -39,10 +41,10 @@ export interface ModuleOptions {
         };
     }>,
     redirect: {
-        login: string;
-        logout: string;
-        callback: string;
-        home: string;
+        login: string | ((auth: Auth, trans?: Function) => string);
+        logout: string | ((auth: Auth, trans?: Function) => string);
+        callback: string | ((auth: Auth, trans?: Function) => string);
+        home: string | ((auth: Auth, trans?: Function) => string);
     };
     initialState?: AuthState;
 }

src/utils/provider.ts

@@ -1,4 +1,4 @@
-import type { Oauth2SchemeOptions, RefreshSchemeOptions, LocalSchemeOptions, CookieSchemeOptions } from '../runtime';
+import type { Oauth2SchemeOptions, RefreshSchemeOptions } from '../runtime';
 import type { StrategyOptions, HTTPRequest, TokenableSchemeOptions } from '../types';
 import type { Nuxt } from '@nuxt/schema';
 import { addServerHandler, addTemplate } from '@nuxt/kit';