@yl546/core-api 1.0.0

package/src/WebSocketClient.ts

@@ -0,0 +1,170 @@
+import EventEmitter from 'eventemitter3';
+
+// 定义存在的事件类型
+export enum WebSocketEventType {
+	Connected = 'connected', // 连接成功
+	Message = 'message', // 接受信息,处理之后的信息
+	RawMessage = 'raw-message', // 原始信息
+	Error = 'error', //错误的时候
+	Disconnected = 'disconnected', //断开连接的时候
+}
+
+export type WebSocketEventListener = (...args: any[]) => any;
+
+export type WebSocketEventValue = `${WebSocketEventType}`;
+
+export type WebSocketEventRawListeners = Partial<Record<WebSocketEventValue, Array<WebSocketEventListener>>>;
+
+export class WebSocketClient extends EventEmitter<WebSocketEventType> {
+	private _endPoint: string;
+	private _protocols?: string | Array<string>;
+	private _rawListeners?: WebSocketEventRawListeners;
+	private _socket: WebSocket;
+	private _loopAnimationRequestId?: number;
+	private _loopSocketHeartBeatTimestamp = 0;
+	private _socketHeartBeatInterval = 5000;
+
+	constructor(endPoint: string, protocols?: string | Array<string>, rawListeners?: WebSocketEventRawListeners) {
+		super();
+
+		this._endPoint = endPoint;
+		this._protocols = protocols;
+		this._rawListeners = rawListeners;
+		this._socket = new WebSocket(endPoint);
+
+		this._socket.addEventListener('open', this._handleOpen);
+		this._socket.addEventListener('message', this._handleMessage);
+		this._socket.addEventListener('error', this._handleError);
+		this._socket.addEventListener('close', this._handleClose);
+
+		this._initListeners();
+	}
+
+	reconnect(): void {
+		this._socket = new WebSocket(this._endPoint);
+
+		this._socket.addEventListener('open', this._handleOpen);
+		this._socket.addEventListener('message', this._handleMessage);
+		this._socket.addEventListener('error', this._handleError);
+		this._socket.addEventListener('close', this._handleClose);
+
+		this._initListeners();
+	}
+
+	deactivate(): void {
+		this._socket.close();
+	}
+
+	send(val: string): void {
+		this._socket.send(val);
+	}
+
+	private _handleOpen = (ev: Event) => {
+		this.emit(WebSocketEventType.Connected, ev);
+
+		this._loop();
+	};
+
+	private _handleMessage = async (ev: MessageEvent) => {
+		try {
+			const data = await this._resolveMessageEvent(ev);
+			this.emit(WebSocketEventType.Message, data);
+		} catch (err) {
+			this.emit(WebSocketEventType.RawMessage, ev);
+		}
+	};
+
+	private _handleError = (ev: Event) => {
+		this.emit(WebSocketEventType.Error, ev);
+	};
+
+	private _handleClose = (ev: CloseEvent) => {
+		if (this._loopAnimationRequestId) {
+			cancelAnimationFrame(this._loopAnimationRequestId);
+		}
+		this.reconnect();
+		this.emit(WebSocketEventType.Disconnected, ev);
+	};
+
+	private _initListeners = (): void => {
+		if (this._rawListeners) {
+			(
+				Object.entries(this._rawListeners) as unknown as Array<[WebSocketEventValue, Array<WebSocketEventListener>]>
+			).forEach(([evt, listeners]) => {
+				switch (evt) {
+					case WebSocketEventType.Connected:
+						listeners.forEach((fn) => {
+							this._socket.addEventListener('open', fn);
+						});
+						break;
+					case WebSocketEventType.Message:
+						listeners.forEach((fn) => {
+							this._socket.addEventListener('message', async (ev: MessageEvent) => {
+								try {
+									const data = await this._resolveMessageEvent(ev);
+									fn(data, ev);
+								} catch (err) {
+									if (listeners[WebSocketEventType.RawMessage]) {
+										listeners[WebSocketEventType.RawMessage].forEach((fn_) => fn_(ev));
+									}
+								}
+							});
+						});
+						break;
+					case WebSocketEventType.RawMessage:
+						listeners.forEach((fn) => {
+							this._socket.addEventListener('message', fn);
+						});
+						break;
+					case WebSocketEventType.Disconnected:
+						listeners.forEach((fn) => {
+							this._socket.addEventListener('close', fn);
+						});
+						break;
+					case WebSocketEventType.Error:
+						listeners.forEach((fn) => {
+							this._socket.addEventListener('error', fn);
+						});
+						break;
+				}
+			});
+		}
+	};
+
+	private _resolveMessageEvent = async (evt: MessageEvent) => {
+		try {
+			const data = JSON.parse(evt.data);
+			return data;
+		} catch (err) {
+			return Promise.reject(err);
+		}
+	};
+
+	//保证websocket出于连接状态
+	private _loop = (): void => {
+		if (this._loopAnimationRequestId) {
+			cancelAnimationFrame(this._loopAnimationRequestId);
+		}
+
+		const now = Date.now();
+
+		if (this._socket) {
+			switch (this._socket.readyState) {
+				case WebSocket.OPEN: //已连接并且可以通讯
+					if (this._loopSocketHeartBeatTimestamp + this._socketHeartBeatInterval < now) {
+						this._loopSocketHeartBeatTimestamp = now;
+
+						this._socket.send('ping');
+					}
+					break;
+				case WebSocket.CLOSED: // 连接已关闭或者没有链接成功
+					this.reconnect();
+				case WebSocket.CLOSING: // 正在关闭
+				case WebSocket.CONNECTING: // 正在连接
+					break;
+			}
+		}
+
+		this._loopAnimationRequestId = requestAnimationFrame(this._loop);
+	};
+}

package/src/constants.ts

@@ -0,0 +1,15 @@
+/** 认证成功业务码 */
+export const AUTHORIZED_CODE = 200;
+/** 认证失败业务码 */
+export const UNAUTHORIZED_CODE = 401;
+
+/** 响应字段默认取值 key */
+export const DEFAULT_RESPONSE_FIELDS = {
+	code: 'code',
+	msg: 'msg',
+	data: 'data',
+	items: 'items',
+	total: 'total',
+	pageNum: 'pageNum',
+	pageSize: 'pageSize',
+} as const;

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './Api';
+export * from './ApiError';
+export * from './constants';
+export * from './types';
+export * from './utils/formatResponseData';
+export * from './utils/resolveResponseFields';
+export * from './WebSocketClient';
+export * from './EventSourceClient';

package/src/types/auth.ts

@@ -0,0 +1,27 @@
+import type { Api } from '../Api';
+
+export interface AuthAdapter<TLoginParams = unknown, TLoginResult = unknown, TCredentials = Record<string, string>> {
+	/** 是否已登录 */
+	isAuthenticated?: () => boolean;
+
+	/** 登录 */
+	login?: (api: Api, params: TLoginParams) => Promise<TLoginResult>;
+
+	/** 主动登出 */
+	logout?: () => Promise<void>;
+
+	/** 每次请求附加的鉴权 headers */
+	getHeaders?: () => Record<string, string | null>;
+
+	/** 登录成功后持久化凭据 */
+	persist?: (result: TLoginResult) => TCredentials;
+
+	/** 清除凭据（401 等鉴权失败时也会调用） */
+	clear?: () => void;
+
+	/** 触发 clear 的业务码，默认 [401] */
+	unauthorizedCodes?: number | number[];
+
+	/** 认证成功业务码 */
+	authorizedCode?: number | number[];
+}

package/src/types/index.ts

@@ -0,0 +1,77 @@
+import { AxiosRequestConfig, InternalAxiosRequestConfig } from 'axios';
+import { Api } from '../Api';
+import { DEFAULT_RESPONSE_FIELDS } from '../constants';
+import { AuthAdapter } from './auth';
+import { LoginResponse } from './login';
+
+export * from './auth';
+export * from './login';
+
+export const VERSION = '1.0.0';
+
+export type ApiResponseFields = Partial<typeof DEFAULT_RESPONSE_FIELDS>;
+
+export type ResolvedApiResponseFields = typeof DEFAULT_RESPONSE_FIELDS;
+
+export type ApiRequestInterceptor = (config: InternalAxiosRequestConfig, api: Api) => InternalAxiosRequestConfig;
+
+export interface ApiEvent {
+	/** 登录成功 */
+	'login-success': (response: LoginResponse) => void;
+	/** 认证失败 */
+	'auth-failed': () => void;
+	/** 登出成功 */
+	'logout-success': () => void;
+}
+
+export interface ApiEndpointConstructor {
+	new (api: Api): any;
+}
+
+export type ApiOptions = {
+	readonly baseUrl?: string;
+	/** 鉴权适配器，由各应用自行配置 */
+	readonly auth?: AuthAdapter;
+	readonly version?: string;
+	readonly endpoints?: Array<ApiEndpointConstructor>;
+	/** 响应字段取值 key 配置 */
+	readonly responseFields?: ApiResponseFields;
+	/** 请求拦截，用于修改入参 */
+	readonly onRequest?: ApiRequestInterceptor;
+};
+
+export type ApiRequestConfig = AxiosRequestConfig & {
+	url: string;
+	query?: { [key: string]: any };
+};
+
+export type RawApiResponse<D> = {
+	code: number;
+	msg: string;
+	data: D;
+	time: number;
+};
+
+export type Pagination = {
+	/** 总条数 */
+	total: number;
+	/** 当前页码 */
+	pageNum: number;
+	/** 每页条数 */
+	pageSize: number;
+};
+
+/**
+ * 分页查询参数
+ */
+export type PaginationQueryParams = {
+	/** 当前页码 */
+	pageNum: number;
+	/** 每页条数 */
+	pageSize: number;
+};
+
+export type PaginationData<T> = {
+	items: T[];
+	pagination: Pagination;
+};

package/src/types/login.ts

@@ -0,0 +1,24 @@
+export interface LoginParams {
+	/** 用户名 */
+	username: string;
+	/** 密码 */
+	password: string;
+}
+
+/** 登录响应 */
+export interface LoginResponse {
+	/** 组织ID */
+	organId: number;
+	/** 员工ID */
+	workerId: number;
+	/** 令牌 */
+	token: string;
+	/** 昵称 */
+	nickname: string;
+	/** 头像 */
+	image: string;
+	/** 经度 */
+	x: string;
+	/** 纬度 */
+	y: string;
+}

package/src/utils/formatResponseData.ts

@@ -0,0 +1,29 @@
+import type { ResolvedApiResponseFields } from '../types';
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return Object.prototype.toString.call(value) === '[object Object]';
+}
+
+/** 将接口 data 格式化为调用方声明的业务类型 T（实体 / 列表 / PaginationData 等） */
+export function formatResponseData<T>(data: unknown, fields: ResolvedApiResponseFields): T {
+	if (Array.isArray(data)) {
+		return data as T;
+	}
+
+	if (isPlainObject(data)) {
+		const items = data[fields.items];
+
+		if (Array.isArray(items)) {
+			return {
+				items,
+				pagination: {
+					total: Number(data[fields.total] ?? 0),
+					pageNum: Number(data[fields.pageNum] ?? 1),
+					pageSize: Number(data[fields.pageSize] ?? 10),
+				},
+			} as T;
+		}
+	}
+
+	return data as T;
+}

package/src/utils/resolveResponseFields.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_RESPONSE_FIELDS } from '../constants';
+import type { ApiResponseFields, ResolvedApiResponseFields } from '../types';
+
+export function resolveResponseFields(fields?: ApiResponseFields): ResolvedApiResponseFields {
+	return {
+		...DEFAULT_RESPONSE_FIELDS,
+		...fields,
+	};
+}
+
+export function readResponseField(source: Record<string, unknown>, key: string) {
+	return source[key];
+}