feat: desctruct project and add pending current session

LorexIQ · Nov 22, 2023 · ae8359d · ae8359d
1 parent 4a8cf36
commit ae8359d
Show file tree

Hide file tree

Showing 8 changed files with 116 additions and 72 deletions.
diff --git a/playground/nuxt.config.ts b/playground/nuxt.config.ts
@@ -9,6 +9,9 @@ export default defineNuxtConfig({
       lifetime: 5,
       path: 'access'
     },
+    sessions: {
+      refreshEvery: 5000
+    },
     refreshToken: {
       enabled: true
     },

diff --git a/playground/pages/index.vue b/playground/pages/index.vue
@@ -10,6 +10,7 @@ definePageMeta({
   <div>
     {{auth}}
     <button @click="() => auth.signOut()">testSignOut</button>
-    <button @click="() => auth.refreshTokenWithCheck()">testRefreshToken</button>
+    <button @click="() => auth.refreshToken()">testRefreshToken</button>
+    <button @click="() => auth.refreshTokenWithCheck()">testRefreshWithCheckToken</button>
   </div>
 </template>
diff --git a/src/module.ts b/src/module.ts
@@ -7,7 +7,7 @@ import {
 } from '@nuxt/kit'
 import defu from "defu";
 
-interface ModuleOptionsEndpointConfig {
+export interface ModuleOptionsEndpointConfig {
   path: string;
   method: 'POST' | 'GET';
 }
@@ -66,24 +66,36 @@ interface ModuleOptionsRefreshToken {
   * */
   bodyKey?: string;
 }
+interface ModuleOptionsSession {
+  /* Enabled refresh user data every N ms. Default: undefined
+  * Example: one getMe request in 5 seconds. value > 5000
+  * Example: disable refresh. value > undefined
+  * */
+  refreshEvery?: number;
+  /* Cookie prefix in app storage. Default: localAuth
+  * Example: localAuth:token -> {token}
+  * */
+  cookiePrefix?: string;
+}
 interface ModuleOptionsPages {
   /* Page for authorization in the system. Default: '/login'
   * */
   auth?: string;
   /* The standard page where to redirect the user after logging in. Default: '/'
   * */
   defaultRedirect?: string;
+  /* A page for catching a server shutdown when it is impossible to
+  * get session data due to a timeout. Default: '/error'
+  * */
+  serverIsDown?: string;
 }
 export interface ModuleOptions {
   /* Path to server. Default: ''
   * Example: 'http://localhost:8000/api/v1' - remote server
   * Example: 'api' - local nuxt server
   * */
   origin: string;
-  /* Cookie prefix in app storage. Default: localAuth
-  * Example: localAuth:token -> {token}
-  * */
-  cookiePrefix?: string;
+  sessions: ModuleOptionsSession;
   token: ModuleOptionsToken;
   refreshToken: ModuleOptionsRefreshToken;
   endpoints: ModuleOptionsEndpoints;
@@ -97,7 +109,10 @@ export default defineNuxtModule<ModuleOptions>({
   },
   defaults: {
     origin: '',
-    cookiePrefix: 'localAuth',
+    sessions: {
+      refreshEvery: undefined,
+      cookiePrefix: 'localAuth',
+    },
     token: {
       lifetime: 86400,
       path: 'token',

diff --git a/src/runtime/composables/useLocalAuth.ts b/src/runtime/composables/useLocalAuth.ts
@@ -1,40 +1,21 @@
-import { useRouter, useNuxtApp, callWithNuxt, useRuntimeConfig } from '#app';
-import { computed } from 'vue';
-import useLocalAuthState from './useLocalAuthState';
-import { LocalAuthError } from '../errors';
-import type {ModuleOptions} from "../../module";
 import type {
   UseLocalAuthData,
-  UseLocalAuthConfig
+  UseLocalAuthConfig,
+  UseLocalAuthResponse
 } from '../types';
-import useUtils from "./useUtils";
-
-const { trimStartWithSymbol } = useUtils();
-
-async function getContext() {
-  const nuxt = useNuxtApp();
-  const options = (await callWithNuxt(nuxt, useRuntimeConfig)).public.localAuth as ModuleOptions;
-  const state = await callWithNuxt(nuxt, useLocalAuthState);
-
-  return {
-    options,
-    state
-  };
-}
+import { useRouter } from '#app';
+import { computed } from 'vue';
+import { LocalAuthError } from '../errors';
+import { fetch, getContext } from '../helpers';
+import useLocalAuthState from './useLocalAuthState';
 
-async function signIn<T = void>(data: UseLocalAuthData, config?: UseLocalAuthConfig): Promise<T> {
-  const { options, state: { origin, saveSession } } = await getContext();
+async function signIn<T extends UseLocalAuthResponse = {}>(data: UseLocalAuthData, config?: UseLocalAuthConfig): Promise<T> {
+  const { options, state: { saveSession } } = await getContext();
   const router = useRouter();
   const endpointConfig = options.endpoints.signIn!;
 
   try {
-    const authData = await $fetch(
-      `${origin}/${trimStartWithSymbol(endpointConfig.path, '/')}`,
-      {
-        method: endpointConfig.method,
-        body: data
-      }
-    );
+    const authData = await fetch<T>(endpointConfig, { body: data });
 
     saveSession(authData);
     await getMe();
@@ -46,19 +27,14 @@ async function signIn<T = void>(data: UseLocalAuthData, config?: UseLocalAuthCon
     else throw new LocalAuthError(e.message);
   }
 }
-async function signOut(config?: UseLocalAuthConfig): Promise<void> {
-  const { options, state: { origin, clearSession } } = await getContext();
+async function signOut<T extends UseLocalAuthResponse = {}>(config?: UseLocalAuthConfig): Promise<T> {
+  const { options, state: { clearSession } } = await getContext();
   const router = useRouter();
   const endpointConfig = options.endpoints.signOut!;
 
   if (options.endpoints.signOut) {
     try {
-      await $fetch(
-        `${origin}/${trimStartWithSymbol(endpointConfig.path, '/')}`,
-        {
-          method: endpointConfig.method
-        }
-      );
+      return await fetch<T>(endpointConfig, { withToken: true });
     } catch (e: any) {
       throw new LocalAuthError(`signOut > [${e.statusCode}] > ${JSON.stringify(e.response._data)}`);
     } finally {
@@ -68,49 +44,42 @@ async function signOut(config?: UseLocalAuthConfig): Promise<void> {
   } else {
     clearSession();
     await router.push(config?.redirectTo ?? options.pages.auth!);
+    return {} as T;
   }
 }
-async function getMe<T>(): Promise<T> {
-  const { options, state: { token, origin, data, meta } } = await getContext();
+async function getMe<T extends UseLocalAuthResponse = {}>(): Promise<T> {
+  const { options, state: { token, data, meta } } = await getContext();
   const endpointConfig = options.endpoints.getMe!;
 
-  if (!token.value) throw new LocalAuthError('getMe > token is null. logout...');
+  if (!token.value) throw new LocalAuthError('getMe > token is null. SignIn first');
 
   try {
-    const meData = await $fetch(
-      `${origin}/${trimStartWithSymbol(endpointConfig.path, '/')}`,
-      {
-        method: endpointConfig.method,
-        headers: {
-          'Authorization': token.value
-        }
-      }
-    );
+    const meData = await fetch<T>(endpointConfig, { withToken: true });
 
     Object.assign(data.value, meData);
     meta.value.status = 'authorized';
 
     return meData;
   } catch (e: any) {
-    throw new LocalAuthError(`getMe > [${e.statusCode}] > ${JSON.stringify(e.response._data)}`);
+    if (e.statusCode) {
+      throw new LocalAuthError(`getMe > [${e.statusCode}] > ${JSON.stringify(e.response._data)}`);
+    } else {
+      throw new LocalAuthError(`getMe > ${e.message}`);
+    }
   }
 }
-async function refreshToken<T>(): Promise<T> {
-  const { options, state: { origin, meta, saveSession } } = await getContext();
+async function refreshToken<T extends UseLocalAuthResponse = {}>(): Promise<T> {
+  const { options, state: { meta, saveSession } } = await getContext();
   const endpointConfig = options.endpoints.refreshToken!;
   const refreshConfig = options.refreshToken;
 
   if (refreshConfig.enabled) {
     try {
-      const refreshData = await $fetch(
-        `${origin}/${trimStartWithSymbol(endpointConfig.path, '/')}`,
-        {
-          method: endpointConfig.method,
-          body: {
-            [`${refreshConfig.bodyKey}`]: meta.value.refreshToken
-          }
+      const refreshData = await fetch<T>(endpointConfig, {
+        body: {
+          [`${refreshConfig.bodyKey}`]: meta.value.refreshToken!
         }
-      );
+      });
 
       saveSession({
         [`${refreshConfig.path}`]: meta.value.refreshToken,
@@ -126,7 +95,7 @@ async function refreshToken<T>(): Promise<T> {
     throw new LocalAuthError('refreshToken > refresh token is disabled. Enable it in refreshToken/enabled');
   }
 }
-async function refreshTokenWithCheck<T>(): Promise<T | null> {
+async function refreshTokenWithCheck<T extends UseLocalAuthResponse = {}>(): Promise<T | null> {
   const { options: { refreshToken: refreshTokenConfig }, state: { meta } } = await getContext();
   const metaData = meta.value;
 
@@ -135,7 +104,7 @@ async function refreshTokenWithCheck<T>(): Promise<T | null> {
     if (metaData.status !== 'authorized') throw Error('session is not found. Use signIn');
     if (Date.now() < +meta.value.exp! * 1000) return null;
 
-    return await refreshToken();
+    return await refreshToken<T>();
   } catch (e: any) {
     throw new LocalAuthError(`refreshTokenWithCheck > ${e.message}`);
   }

diff --git a/src/runtime/composables/useLocalAuthState.ts b/src/runtime/composables/useLocalAuthState.ts
@@ -15,7 +15,7 @@ export default function () {
   const options = useRuntimeConfig().public.localAuth as ModuleOptions;
 
   const sessionData = useState<UseLocalAuthCredentials>('localAuth:Credentials', () => ({}));
-  const cookieData = useState('localAuth:Cookie', () => useCookie<UseLocalAuthSession | null>('localAuth', { default: () => null }));
+  const cookieData = useState('localAuth:Cookie', () => useCookie<UseLocalAuthSession | null>(options.sessions.cookiePrefix!, { default: () => null }));
   const sessionMetaInfo: Ref<UseLocalAuthSession> = useState('localAuth:Meta', () => ({
     token: null,
     refreshToken: null,

diff --git a/src/runtime/helpers.ts b/src/runtime/helpers.ts
@@ -0,0 +1,37 @@
+import type {ModuleOptions, ModuleOptionsEndpointConfig} from "../module";
+import type {UseLocalAuthFetchConfig, UseLocalAuthResponse} from "./types";
+import {callWithNuxt, useNuxtApp, useRuntimeConfig} from "#app";
+import useLocalAuthState from "./composables/useLocalAuthState";
+import useUtils from "./composables/useUtils";
+
+const { trimStartWithSymbol } = useUtils();
+
+export async function getContext() {
+  const nuxt = useNuxtApp();
+  const options = (await callWithNuxt(nuxt, useRuntimeConfig)).public.localAuth as ModuleOptions;
+  const state = await callWithNuxt(nuxt, useLocalAuthState);
+
+  return {
+    options,
+    state
+  };
+}
+export async function fetch<T extends UseLocalAuthResponse>(
+  endpoint: ModuleOptionsEndpointConfig,
+  _config: UseLocalAuthFetchConfig
+): Promise<T> {
+  const config: UseLocalAuthFetchConfig = {
+    withToken: false,
+    ..._config,
+  }
+  const { state: { token, origin} } = await getContext();
+
+  return await $fetch(
+    `${origin}/${trimStartWithSymbol(endpoint.path, '/')}`,
+    {
+      method: endpoint.method,
+      body: config.body,
+      headers: config.withToken ? { 'Authorization': token.value! } : {}
+    }
+  );
+}
diff --git a/src/runtime/plugin.ts b/src/runtime/plugin.ts
@@ -1,14 +1,29 @@
 import { defineNuxtPlugin, addRouteMiddleware } from '#app'
-import { useLocalAuth } from '#imports'
+import { useLocalAuth, watch } from '#imports'
+import { getContext } from './helpers';
 import auth from "./middleware/auth";
 
 export default defineNuxtPlugin(async () => {
-  const { token, getMe } = useLocalAuth()
+  const { options, state: { token } } = await getContext();
+  const { getMe } = useLocalAuth();
+  let pendingInterval: NodeJS.Timeout;
 
   try {
     if (token.value) await getMe();
   } catch (e) {}
 
+  if (options.sessions.refreshEvery) {
+    watch(token, value => {
+      clearInterval(pendingInterval);
+      if (value) {
+        pendingInterval = setInterval(async () => {
+          if (token.value) await getMe();
+          else clearInterval(pendingInterval);
+        }, options.sessions.refreshEvery);
+      }
+    }, { immediate: true });
+  }
+
   addRouteMiddleware('auth', auth, {
     global: true
   });

diff --git a/src/runtime/types.ts b/src/runtime/types.ts
@@ -22,3 +22,7 @@ export interface UseLocalAuthSession {
   exp: string | null;
   status: UseLocalAuthStatus;
 }
+export interface UseLocalAuthFetchConfig {
+  withToken?: boolean;
+  body?: UseLocalAuthData;
+}