alovajs / scene / #40

Committed 01 Mar 2024 08:13AM UTC coverage: 97.979%. Remained the same

Build # #40

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #54 from alovajs/release/v1.4.x

Release v1.4.4

Run Details

779 of 828 branches covered (94.08%)

Branch coverage included in aggregate %.

26 of 26 new or added lines in 3 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

4408 of 4466 relevant lines covered (98.7%)

92.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.94

/src/functions/tokenAuthentication/helper.ts

import { forEach, instanceOf, isFn, isPlainOrCustomObject, len, newInstance, noop, pushItem, splice } from '@/helper';
import { falseValue, PromiseCls, trueValue, undefinedValue } from '@/helper/variables';
import {
  AlovaRequestAdapter,
  Method,
  ResponseCompleteHandler,
  ResponsedHandler,
  ResponseErrorHandler,
  StatesHook
} from 'alova';
import { AlovaResponded, MetaMatches, ResponseAuthorizationInterceptor } from '~/typings/general';

export type PosibbleAuthMap =
  | {
      metaMatches?: MetaMatches;
      handler: any;
    }
  | undefined;
export type WaitingRequestList = {
  method: Method;
  resolve: () => void;
}[];

export const defaultVisitorMeta = {
    authRole: null
  },
  defaultLoginMeta = {
    authRole: 'login'
  },
  defaultLogoutMeta = {
    authRole: 'logout'
  },
  defaultRefreshTokenMeta = {
    authRole: 'refreshToken'
  },
  checkMethodRole = ({ meta }: Method, metaMatches: MetaMatches) => {
    if (isPlainOrCustomObject<Record<string, any>>(meta)) {
      for (const key in meta) {
        const matchedMetaItem = metaMatches[key];
        if (instanceOf(matchedMetaItem, RegExp) ? matchedMetaItem.test(meta[key]) : meta[key] === matchedMetaItem) {
          return trueValue;
        }
      }
    }
    return falseValue;
  },
  waitForTokenRefreshed = (method: Method, waitingList: WaitingRequestList) =>
    newInstance(PromiseCls, resolve => {
      pushItem(waitingList, {
        method,
        resolve
      });
    }),
  callHandlerIfMatchesMeta = (
    method: Method,
    authorizationInterceptor:
      | ResponseAuthorizationInterceptor<AlovaRequestAdapter<any, any, any, any, any>>
      | undefined,
    defaultMeta: MetaMatches,
    response: any
  ) => {
    if (checkMethodRole(method, (authorizationInterceptor as PosibbleAuthMap)?.metaMatches || defaultMeta)) {
      const handler = isFn(authorizationInterceptor)
        ? authorizationInterceptor
        : isPlainOrCustomObject<NonNullable<typeof authorizationInterceptor>>(authorizationInterceptor) &&
          isFn(authorizationInterceptor.handler)
        ? authorizationInterceptor.handler
        : noop;
      handler(response, method);
    }
  },
  refreshTokenIfExpired = async (
    method: Method,
    waitingList: WaitingRequestList,
    updateRefreshStatus: (status: boolean) => void,
    handlerParams: any[],
    refreshToken?: {
      isExpired: (...args: any[]) => boolean | Promise<boolean>;
      handler: (...args: any[]) => Promise<void>;
    },
    tokenRefreshing?: boolean
  ) => {
    // 当handleParams数量大于2时，说明是从响应中调用此函数的，此时需要重新请求原接口
    const fromResponse = len(handlerParams) >= 2;
    let isExpired = refreshToken?.isExpired(...handlerParams);
    // 兼容处理同步函数和异步函数
    if (instanceOf(isExpired, PromiseCls)) {
      isExpired = await isExpired;
    }

    if (isExpired) {
      try {
        // 在响应中再次判断，防止请求多次刷新token，把在token刷新完成前发送的拦截并等待
        let intentToRefreshToken = trueValue;
        if (fromResponse && tokenRefreshing) {
          intentToRefreshToken = falseValue; // 在此等待的请求表示token刷新中，当它们通过后不再需要再次刷新token了
          await waitForTokenRefreshed(method, waitingList);
        }

        if (intentToRefreshToken) {
          updateRefreshStatus(trueValue);
          // 调用刷新token
          await refreshToken?.handler(...handlerParams);
          updateRefreshStatus(falseValue);
          // 刷新token完成后，通知等待列表中的请求
          forEach(waitingList, ({ resolve }) => resolve());
        }
        if (fromResponse) {
          // 这里因为是重新请求原接口，与上一次请求叠加会导致重复调用transformData，因此需要将transformData置空去除一次调用
          const config = method.config,
            methodTransformData = config.transformData;
          config.transformData = undefinedValue;
          const resentData = await method;
          config.transformData = methodTransformData;
          return resentData;
        }
      } finally {
        updateRefreshStatus(falseValue);
        splice(waitingList, 0, len(waitingList)); // 清空waitingList
      }
    }
  },
  onResponded2Record = (
    onRespondedHandlers?: AlovaResponded<StatesHook<any, any>, AlovaRequestAdapter<any, any, any, any, any>>
  ) => {
    let successHandler: ResponsedHandler<any, any, any, any, any> | undefined = undefinedValue,
      errorHandler: ResponseErrorHandler<any, any, any, any, any> | undefined = undefinedValue,
      onCompleteHandler: ResponseCompleteHandler<any, any, any, any, any> | undefined = undefinedValue;
    if (isFn(onRespondedHandlers)) {
      successHandler = onRespondedHandlers;
    } else if (isPlainOrCustomObject<NonNullable<typeof onRespondedHandlers>>(onRespondedHandlers)) {
      const { onSuccess, onError, onComplete } = onRespondedHandlers;
      successHandler = isFn(onSuccess) ? onSuccess : successHandler;
      errorHandler = isFn(onError) ? onError : errorHandler;
      onCompleteHandler = isFn(onComplete) ? onComplete : onCompleteHandler;
    }
    return {
      onSuccess: successHandler,
      onError: errorHandler,
      onComplete: onCompleteHandler
    };
  };

1	import { forEach, instanceOf, isFn, isPlainOrCustomObject, len, newInstance, noop, pushItem, splice } from '@/helper';	1✔
2	import { falseValue, PromiseCls, trueValue, undefinedValue } from '@/helper/variables';	1✔
3	import {	1✔
4	AlovaRequestAdapter,	1✔
5	Method,	1✔
6	ResponseCompleteHandler,	1✔
7	ResponsedHandler,	1✔
8	ResponseErrorHandler,	1✔
9	StatesHook	1✔
10	} from 'alova';	1✔
11	import { AlovaResponded, MetaMatches, ResponseAuthorizationInterceptor } from '~/typings/general';	1✔
12		1✔
13	export type PosibbleAuthMap =	1✔
14	\| {	1✔
15	metaMatches?: MetaMatches;	1✔
16	handler: any;	1✔
17	}	1✔
18	\| undefined;	1✔
19	export type WaitingRequestList = {	1✔
20	method: Method;	1✔
21	resolve: () => void;	1✔
22	}[];	1✔
23		1✔
24	export const defaultVisitorMeta = {	1✔
25	authRole: null	1✔
26	},	1✔
27	defaultLoginMeta = {	1✔
28	authRole: 'login'	1✔
29	},	1✔
30	defaultLogoutMeta = {	1✔
31	authRole: 'logout'	1✔
32	},	1✔
33	defaultRefreshTokenMeta = {	1✔
34	authRole: 'refreshToken'	1✔
35	},	1✔
36	checkMethodRole = ({ meta }: Method, metaMatches: MetaMatches) => {	1✔
37	if (isPlainOrCustomObject<Record<string, any>>(meta)) {	270✔
38	for (const key in meta) {	118✔
39	const matchedMetaItem = metaMatches[key];	118✔
40	if (instanceOf(matchedMetaItem, RegExp) ? matchedMetaItem.test(meta[key]) : meta[key] === matchedMetaItem) {	118!
41	return trueValue;	32✔
42	}	32✔
43	}	118✔
44	}	86✔
45	return falseValue;	238✔
46	},	238✔
47	waitForTokenRefreshed = (method: Method, waitingList: WaitingRequestList) =>	1✔
48	newInstance(PromiseCls, resolve => {	3✔
49	pushItem(waitingList, {	3✔
50	method,	3✔
51	resolve	3✔
52	});	3✔
53	}),	1✔
54	callHandlerIfMatchesMeta = (	1✔
55	method: Method,	62✔
56	authorizationInterceptor:	62✔
57	\| ResponseAuthorizationInterceptor<AlovaRequestAdapter<any, any, any, any, any>>	62✔
58	\| undefined,	62✔
59	defaultMeta: MetaMatches,	62✔
60	response: any	62✔
61	) => {	62✔
62	if (checkMethodRole(method, (authorizationInterceptor as PosibbleAuthMap)?.metaMatches \|\| defaultMeta)) {	62✔
63	const handler = isFn(authorizationInterceptor)	8✔
64	? authorizationInterceptor	8✔
65	: isPlainOrCustomObject<NonNullable<typeof authorizationInterceptor>>(authorizationInterceptor) &&	8✔
66	isFn(authorizationInterceptor.handler)	4✔
67	? authorizationInterceptor.handler	4✔
68	: noop;	8!
69	handler(response, method);	8✔
70	}	8✔
71	},	62✔
72	refreshTokenIfExpired = async (	1✔
73	method: Method,	27✔
74	waitingList: WaitingRequestList,	27✔
75	updateRefreshStatus: (status: boolean) => void,	27✔
76	handlerParams: any[],	27✔
77	refreshToken?: {	27✔
78	isExpired: (...args: any[]) => boolean \| Promise<boolean>;	27✔
79	handler: (...args: any[]) => Promise<void>;	27✔
80	},	27✔
81	tokenRefreshing?: boolean	27✔
82	) => {	27✔
83	// 当handleParams数量大于2时，说明是从响应中调用此函数的，此时需要重新请求原接口	27✔
84	const fromResponse = len(handlerParams) >= 2;	27✔
85	let isExpired = refreshToken?.isExpired(...handlerParams);	27✔
86	// 兼容处理同步函数和异步函数	27✔
87	if (instanceOf(isExpired, PromiseCls)) {	27!
UNCOV 88	isExpired = await isExpired;	×
UNCOV 89	}	×
90		27✔
91	if (isExpired) {	27✔
92	try {	9✔
93	// 在响应中再次判断，防止请求多次刷新token，把在token刷新完成前发送的拦截并等待	9✔
94	let intentToRefreshToken = trueValue;	9✔
95	if (fromResponse && tokenRefreshing) {	9✔
96	intentToRefreshToken = falseValue; // 在此等待的请求表示token刷新中，当它们通过后不再需要再次刷新token了	1✔
97	await waitForTokenRefreshed(method, waitingList);	1✔
98	}	1✔
99		9✔
100	if (intentToRefreshToken) {	9✔
101	updateRefreshStatus(trueValue);	8✔
102	// 调用刷新token	8✔
103	await refreshToken?.handler(...handlerParams);	8!
104	updateRefreshStatus(falseValue);	6✔
105	// 刷新token完成后，通知等待列表中的请求	6✔
106	forEach(waitingList, ({ resolve }) => resolve());	6✔
107	}	6✔
108	if (fromResponse) {	8✔
109	// 这里因为是重新请求原接口，与上一次请求叠加会导致重复调用transformData，因此需要将transformData置空去除一次调用	5✔
110	const config = method.config,	5✔
111	methodTransformData = config.transformData;	5✔
112	config.transformData = undefinedValue;	5✔
113	const resentData = await method;	5✔
114	config.transformData = methodTransformData;	5✔
115	return resentData;	5✔
116	}	5✔
117	} finally {	9✔
118	updateRefreshStatus(falseValue);	9✔
119	splice(waitingList, 0, len(waitingList)); // 清空waitingList	9✔
120	}	9✔
121	}	9✔
122	},	27✔
123	onResponded2Record = (	1✔
124	onRespondedHandlers?: AlovaResponded<StatesHook<any, any>, AlovaRequestAdapter<any, any, any, any, any>>	24✔
125	) => {	24✔
126	let successHandler: ResponsedHandler<any, any, any, any, any> \| undefined = undefinedValue,	24✔
127	errorHandler: ResponseErrorHandler<any, any, any, any, any> \| undefined = undefinedValue,	24✔
128	onCompleteHandler: ResponseCompleteHandler<any, any, any, any, any> \| undefined = undefinedValue;	24✔
129	if (isFn(onRespondedHandlers)) {	24✔
130	successHandler = onRespondedHandlers;	13✔
131	} else if (isPlainOrCustomObject<NonNullable<typeof onRespondedHandlers>>(onRespondedHandlers)) {	24✔
132	const { onSuccess, onError, onComplete } = onRespondedHandlers;	2✔
133	successHandler = isFn(onSuccess) ? onSuccess : successHandler;	2!
134	errorHandler = isFn(onError) ? onError : errorHandler;	2!
135	onCompleteHandler = isFn(onComplete) ? onComplete : onCompleteHandler;	2!
136	}	2✔
137	return {	24✔
138	onSuccess: successHandler,	24✔
139	onError: errorHandler,	24✔
140	onComplete: onCompleteHandler	24✔
141	};	24✔
142	};	24✔

alovajs / scene / #40

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous