@yl546/core-api 1.0.0

package/dist/types/index.d.ts

@@ -0,0 +1,66 @@
+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 declare 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/dist/types/login.d.ts

@@ -0,0 +1,23 @@
+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/dist/utils/formatResponseData.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedApiResponseFields } from '../types';
+/** 将接口 data 格式化为调用方声明的业务类型 T（实体 / 列表 / PaginationData 等） */
+export declare function formatResponseData<T>(data: unknown, fields: ResolvedApiResponseFields): T;

package/dist/utils/resolveResponseFields.d.ts

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

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@yl546/core-api",
+	"version": "1.0.0",
+	"description": "",
+	"type": "module",
+	"keywords": [],
+	"author": "",
+	"license": "ISC",
+	"files": [
+		"dist",
+		"src"
+	],
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"dependencies": {
+		"axios": "^1.16.0",
+		"eventemitter3": "^5.0.4",
+		"query-string": "^9.3.1",
+		"uuid": "^14.0.0"
+	},
+	"peerDependencies": {
+		"vue": "3.5.33"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/Api.ts

@@ -0,0 +1,328 @@
+import QS from 'query-string';
+import Axios, { AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import EventEmitter from 'eventemitter3';
+import { App, inject, InjectionKey } from 'vue';
+import {
+	ApiEndpointConstructor,
+	ApiEvent,
+	ApiOptions,
+	ApiRequestConfig,
+	AuthAdapter,
+	LoginParams,
+	LoginResponse,
+	RawApiResponse,
+	VERSION,
+} from './types';
+import { ApiError } from './ApiError';
+import { WebSocketClient, WebSocketEventRawListeners } from './WebSocketClient';
+import { v4 as uuidv4 } from 'uuid';
+import { AUTHORIZED_CODE, UNAUTHORIZED_CODE } from './constants';
+import { formatResponseData } from './utils/formatResponseData';
+import { readResponseField, resolveResponseFields } from './utils/resolveResponseFields';
+
+export type ApiWithEndpoints<Instance extends Api, Endpoints extends ApiEndpoints = any> = Instance & Endpoints;
+
+export declare interface ApiEndpoints {}
+
+export type InitWebSocketOptions = {
+	override?: boolean;
+	protocols?: string | string[];
+	listeners?: WebSocketEventRawListeners;
+};
+
+export type ApiInstance = ApiWithEndpoints<Api, ApiEndpoints>;
+
+declare module 'vue' {
+	interface ComponentCustomProperties {
+		$api: ApiInstance;
+	}
+}
+
+export const API_CONTEXT_KEY: InjectionKey<ApiInstance> = Symbol.for('API_CONTEXT_KEY');
+
+/** 请求取消控制器映射 */
+const abortControllerMap = new Map<string, AbortController>();
+
+export const useApi = () => {
+	const $api = inject(API_CONTEXT_KEY);
+
+	if (!$api) {
+		throw new Error('Api not found');
+	}
+
+	return $api;
+};
+
+export class Api extends EventEmitter<ApiEvent> {
+	static VERSION = VERSION;
+
+	readonly version: string = VERSION;
+	readonly options: Readonly<ApiOptions>;
+	readonly auth: AuthAdapter;
+	readonly sockets: Record<string, WebSocketClient> = {};
+
+	private _axios: AxiosInstance;
+
+	static install = (app: App, options: ApiOptions): void => {
+		const api = new Api(options);
+
+		app.provide('$apiConfig', options);
+		app.provide(API_CONTEXT_KEY, api as ApiInstance);
+		app.config.globalProperties.$api = api as ApiInstance;
+	};
+
+	private _responseFields: ReturnType<typeof resolveResponseFields>;
+
+	constructor(options: ApiOptions) {
+		super();
+
+		this.auth = options.auth ?? {};
+		this.options = options;
+		this._responseFields = resolveResponseFields(options.responseFields);
+		this._axios = Axios.create({
+			baseURL: options.baseUrl ?? '',
+			timeout: 10000,
+		});
+
+		this._axios.interceptors.request.use(this._requestInterceptor.bind(this));
+		this._axios.interceptors.response.use(this._responseInterceptor.bind(this));
+
+		this.$request = this.$request.bind(this);
+		this.$post = this.$post.bind(this);
+		this.$get = this.$get.bind(this);
+		this.$put = this.$put.bind(this);
+		this.$delete = this.$delete.bind(this);
+
+		if (options.endpoints) {
+			this.use(options.endpoints);
+		}
+
+		if (options.version) {
+			this.version = options.version;
+		}
+	}
+
+	get host(): string {
+		return location.host;
+	}
+
+	use(EndPoint: ApiEndpointConstructor | Array<ApiEndpointConstructor>): ThisType<Api> {
+		if (Array.isArray(EndPoint)) {
+			EndPoint.forEach((p) => this.use(p));
+
+			return this;
+		}
+
+		if (EndPoint) {
+			const endPoint = new EndPoint(this);
+			const name = endPoint.name || EndPoint.name;
+
+			if (Object.prototype.hasOwnProperty.call(this, name)) {
+				return this;
+			}
+
+			this.addEndPoint(name, endPoint);
+		}
+
+		return this;
+	}
+
+	addEndPoint(name: string, endPoint: any, enumerable = true): ThisType<Api> {
+		Object.defineProperty(this, name, {
+			value: endPoint,
+			writable: false,
+			configurable: false,
+			enumerable,
+		});
+
+		return this;
+	}
+
+	/** 登录 */
+	async login(params: LoginParams): Promise<LoginResponse> {
+		try {
+			if (!this.auth.login) {
+				throw new Error('Login method not implemented');
+			}
+
+			const result = await this.auth.login(this, params);
+
+			this.auth.persist?.(result);
+			this.emit('login-success', result as LoginResponse);
+
+			return result as LoginResponse;
+		} catch (error) {
+			throw error;
+		}
+	}
+
+	/** 登出 */
+	async logout(): Promise<void> {
+		try {
+			if (!this.auth.logout) {
+				throw new Error('Logout method not implemented');
+			}
+
+			await this.auth.logout?.();
+			this.auth.clear?.();
+			this.emit('logout-success');
+		} catch (error) {
+			throw error;
+		}
+	}
+
+	/** 取消所有请求 */
+	cancelAllRequest() {
+		abortControllerMap.forEach((controller) => {
+			controller.abort();
+		});
+		abortControllerMap.clear();
+	}
+
+	async $request<D = any>(config: ApiRequestConfig): Promise<D> {
+		const controller = new AbortController();
+		const requestId = uuidv4();
+		abortControllerMap.set(requestId, controller);
+		let response: AxiosResponse<RawApiResponse<D>>;
+		const { query, url, ...conf } = config;
+
+		const urlObject = QS.parseUrl(url);
+
+		if (query) {
+			Object.assign(urlObject.query, query);
+		}
+
+		Object.assign(conf, {
+			url: QS.stringifyUrl(urlObject),
+		});
+
+		try {
+			response = await this._axios.request({
+				...conf,
+				signal: controller.signal,
+				headers: {
+					...conf.headers,
+					...this.auth.getHeaders?.(),
+				},
+			});
+		} catch (error: any) {
+			if (Axios.isCancel(error)) {
+				throw error;
+			}
+
+			const codeMessage: any[] = error.message.split('status code ');
+			let code = '';
+			if (codeMessage && codeMessage.length) {
+				code = codeMessage[codeMessage.length - 1];
+			}
+			throw new ApiError(`请求错误，http状态码：${code}`, Number(code), {});
+		} finally {
+			abortControllerMap.delete(requestId);
+		}
+
+		const { data: rawData } = response;
+		const raw = rawData as Record<string, unknown>;
+		const fields = this._responseFields;
+
+		const code = Number(readResponseField(raw, fields.code));
+		const msg = String(readResponseField(raw, fields.msg) ?? '未知异常');
+		const data = readResponseField(raw, fields.data);
+
+		const authorizedCode = ([] as number[]).concat(this.auth.authorizedCode ?? AUTHORIZED_CODE);
+		const unauthorizedCodes = ([] as number[]).concat(this.auth.unauthorizedCodes ?? UNAUTHORIZED_CODE);
+
+		if (authorizedCode.includes(code)) {
+			return formatResponseData<D>(data, fields);
+		}
+
+		if (unauthorizedCodes.includes(code)) {
+			this.cancelAllRequest();
+			this.auth.clear?.();
+			this.emit('auth-failed');
+		}
+
+		throw new ApiError(msg, code);
+	}
+
+	$post<D = any>(url: string, data?: any, config?: Partial<ApiRequestConfig>): Promise<D> {
+		return this.$request<D>(
+			Object.assign({
+				...config,
+				url,
+				data,
+				method: 'POST',
+			}),
+		);
+	}
+
+	$get<D = any, Q = any>(url: string, query?: Q, config?: Partial<ApiRequestConfig>): Promise<D> {
+		return this.$request<D>(
+			Object.assign({
+				...config,
+				url,
+				query,
+				method: 'GET',
+			}),
+		);
+	}
+
+	$put<D = any>(url: string, data?: any, config?: Partial<ApiRequestConfig>): Promise<D> {
+		return this.$request<D>(
+			Object.assign({
+				...config,
+				url,
+				data,
+				method: 'PUT',
+			}),
+		);
+	}
+
+	$delete<D = any, Q = any>(url: string, query?: Q, config?: Partial<ApiRequestConfig>): Promise<D> {
+		return this.$request<D>(
+			Object.assign({
+				...config,
+				url,
+				query,
+				method: 'DELETE',
+			}),
+		);
+	}
+
+	private _requestInterceptor(config: InternalAxiosRequestConfig) {
+		if (this.options.onRequest) {
+			return this.options.onRequest(config, this);
+		}
+
+		return config;
+	}
+
+	private _responseInterceptor(response: AxiosResponse): AxiosResponse {
+		return response;
+	}
+
+	setWebSocket = async (name: string, endpoint: string, options_?: InitWebSocketOptions): Promise<WebSocketClient> => {
+		const options = Object.assign(
+			{
+				override: false,
+			},
+			options_,
+		);
+
+		if (this.sockets[name]) {
+			if (!options.override) {
+				throw new Error(`${name} has been initilized.`);
+			} else {
+				this.sockets[name].deactivate();
+			}
+		}
+
+		Object.defineProperty(this.sockets, name, {
+			value: new WebSocketClient(endpoint, options.protocols, options.listeners),
+			configurable: true,
+			enumerable: true,
+			writable: false,
+		});
+
+		return this.sockets[name]!;
+	};
+}

package/src/ApiError.ts

@@ -0,0 +1,23 @@
+import { AxiosResponse } from "axios";
+import { ApiRequestConfig } from "./types";
+
+export type ApiErrorOptions<D> = Partial<{
+  data: D;
+  requestConfig: ApiRequestConfig;
+  response: AxiosResponse;
+}>;
+
+export class ApiError<D> extends Error {
+  readonly code: number;
+  readonly requestConfig?: ApiRequestConfig;
+  readonly response?: AxiosResponse;
+  readonly data?: D;
+
+  constructor(message: string, code: number, options?: ApiErrorOptions<D>) {
+    super(message);
+
+    this.code = code;
+
+    Object.assign(this, options);
+  }
+}

package/src/EventSourceClient.ts

@@ -0,0 +1,189 @@
+import EventEmitter from 'eventemitter3';
+
+export enum EventSourceEventType {
+	Connected = 'connected',
+	Message = 'message',
+	RawMessage = 'raw-message',
+	Error = 'error',
+	Disconnected = 'disconnected',
+}
+
+export type EventSourceEventListener = (...args: any[]) => any;
+
+export type EventSourceEventValue = `${EventSourceEventType}`;
+
+export type EventSourceEventRawListeners = Partial<Record<EventSourceEventValue, Array<EventSourceEventListener>>>;
+
+export type EventSourceClientOptions = {
+	withCredentials?: boolean;
+	reconnectInterval?: number;
+	/** 是否在实例化时自动连接，默认 true */
+	autoConnect?: boolean;
+};
+
+const DEFAULT_RECONNECT_INTERVAL = 3000;
+
+export class EventSourceClient extends EventEmitter<EventSourceEventType> {
+	private _endPoint: string;
+	private _options: EventSourceClientOptions;
+	private _rawListeners?: EventSourceEventRawListeners;
+	private _source?: EventSource;
+	private _active: boolean;
+	private _reconnectTimer?: ReturnType<typeof setTimeout>;
+
+	constructor(endPoint: string, options: EventSourceClientOptions = {}, rawListeners?: EventSourceEventRawListeners) {
+		super();
+
+		this._endPoint = endPoint;
+		this._options = options;
+		this._rawListeners = rawListeners;
+		this._active = options.autoConnect !== false;
+
+		if (this._active) {
+			this._connect();
+		}
+	}
+
+	/** 手动建立连接（已连接或连接中时跳过） */
+	connect(): void {
+		this._active = true;
+		this._clearReconnectTimer();
+
+		const state = this._source?.readyState;
+		if (state === EventSource.OPEN || state === EventSource.CONNECTING) {
+			return;
+		}
+
+		this._destroySource();
+		this._connect();
+	}
+
+	/** 重新连接 */
+	reconnect(): void {
+		this._active = true;
+		this._clearReconnectTimer();
+		this._destroySource();
+		this._connect();
+	}
+	/** 禁用连接 */
+	deactivate(): void {
+		this._active = false;
+		this._clearReconnectTimer();
+		this._destroySource();
+	}
+
+	private _connect(): void {
+		if (!this._active) {
+			return;
+		}
+
+		this._source = new EventSource(this._endPoint, { withCredentials: this._options.withCredentials });
+
+		this._source.addEventListener('open', this._handleOpen);
+		this._source.addEventListener('message', this._handleMessage);
+		this._source.addEventListener('error', this._handleError);
+
+		this._bindRawListeners();
+	}
+
+	private _destroySource(): void {
+		if (!this._source) {
+			return;
+		}
+
+		this._source.removeEventListener('open', this._handleOpen);
+		this._source.removeEventListener('message', this._handleMessage);
+		this._source.removeEventListener('error', this._handleError);
+		this._source.close();
+		this._source = undefined;
+	}
+
+	private _clearReconnectTimer(): void {
+		if (this._reconnectTimer) {
+			clearTimeout(this._reconnectTimer);
+			this._reconnectTimer = undefined;
+		}
+	}
+
+	private _scheduleReconnect(): void {
+		if (!this._active || this._reconnectTimer) {
+			return;
+		}
+
+		this._reconnectTimer = setTimeout(() => {
+			this._reconnectTimer = undefined;
+			this.reconnect();
+		}, this._options.reconnectInterval ?? DEFAULT_RECONNECT_INTERVAL);
+	}
+
+	private _handleOpen = (ev: Event) => {
+		this.emit(EventSourceEventType.Connected, ev);
+	};
+
+	private _handleMessage = (ev: MessageEvent) => {
+		try {
+			this.emit(EventSourceEventType.Message, this._parseMessage(ev));
+		} catch {
+			this.emit(EventSourceEventType.RawMessage, ev);
+		}
+	};
+
+	private _handleError = (ev: Event) => {
+		this.emit(EventSourceEventType.Error, ev);
+
+		if (!this._source || this._source.readyState !== EventSource.CLOSED) {
+			return;
+		}
+
+		this.emit(EventSourceEventType.Disconnected, ev);
+		this._scheduleReconnect();
+	};
+
+	private _bindRawListeners = (): void => {
+		if (!this._rawListeners || !this._source) {
+			return;
+		}
+
+		const source = this._source;
+
+		(
+			Object.entries(this._rawListeners) as unknown as Array<[EventSourceEventValue, Array<EventSourceEventListener>]>
+		).forEach(([evt, listeners]) => {
+			switch (evt) {
+				case EventSourceEventType.Connected:
+					listeners.forEach((fn) => source.addEventListener('open', fn));
+					break;
+				case EventSourceEventType.Message:
+					listeners.forEach((fn) => {
+						source.addEventListener('message', (ev: MessageEvent) => {
+							try {
+								fn(this._parseMessage(ev), ev);
+							} catch {
+								this._rawListeners?.[EventSourceEventType.RawMessage]?.forEach((rawFn) => rawFn(ev));
+							}
+						});
+					});
+					break;
+				case EventSourceEventType.RawMessage:
+					listeners.forEach((fn) => source.addEventListener('message', fn));
+					break;
+				case EventSourceEventType.Disconnected:
+					listeners.forEach((fn) => {
+						source.addEventListener('error', (ev: Event) => {
+							if (this._source?.readyState === EventSource.CLOSED) {
+								fn(ev);
+							}
+						});
+					});
+					break;
+				case EventSourceEventType.Error:
+					listeners.forEach((fn) => source.addEventListener('error', fn));
+					break;
+			}
+		});
+	};
+
+	private _parseMessage(evt: MessageEvent) {
+		return JSON.parse(evt.data);
+	}
+}