Skip to content

Project handlers ​

.use(fn) replaces a handler; handlers do not accumulate like Axios interceptor queues.

Message ​

ts
fastAxios.message.success.use((message) => {});
fastAxios.message.warning.use((message) => {});
fastAxios.message.info.use((message) => {});
fastAxios.message.error.use((message) => {});

Defaults to console output when unregistered. The request core does not duplicate logging before throwing.

Loading ​

ts
fastAxios.loading.show.use((text) => {});
fastAxios.loading.close.use((options) => {});

The default implementation does nothing. The SDK does not maintain a global concurrent-request counter; application handlers must prevent one request from closing another request's loading indicator.

Cache ​

ts
fastAxios.cache.get.use((key) => storage.get(key));
fastAxios.cache.set.use((key, value) => storage.set(key, value));

Defaults to an in-process Map with up to 256 entries and a five-minute TTL. Readers should return null or undefined for cache misses; false, 0, and empty strings are valid cached values.

Caching applies only to requests satisfying all of these conditions:

  • cache: true;
  • GET;
  • restfulResult: true;
  • simpleDataFormat: true。

Caches the final value returned to the caller, not the raw AxiosResponse.

Crypto ​

ts
fastAxios.crypto.encrypt.use((config, timestamp) => {
	// May modify data, params, or headers.
});

fastAxios.crypto.decrypt.use((response, options) => {
	return response.data;
});

The default encryptor leaves requests unchanged; the default decryptor returns response.data. requestCipher: true alone provides no encryption security. Register implementations matching the server protocol.

Interceptors ​

ts
fastAxios.interceptors.request.use((config) => {});

fastAxios.interceptors.response.use((response, options) => {
	return undefined;
});

fastAxios.interceptors.responseError.use((error, options) => {
	return undefined;
});
  • request may mutate the Axios internal request configuration.
  • A non-nullish response result takes over success handling, skipping file, RESTful, decryption, and caching logic.
  • A non-nullish responseError result replaces the final rejection; non-Error values are wrapped in AxiosError.

These are single Fast project handlers. Axios instances still use standard request/response interceptors for their lifecycle.

MessageBox ​

ts
fastAxios.messageBox.confirm.use(async (options) => {
	// Resolve on confirmation; throw or return a rejected Promise on cancellation.
});

Defaults to uni.showModal, then browser window.confirm. Resolves on confirmation; rejects on cancellation, platform failure, or unsupported runtimes.

fastAxios.message.success Success ​

Calls the current success-message handler.

Signature ​

ts
(message: string): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.success("操作完成");

Input ​

InputTypeRequired / defaultDescription
messagestringRequiredMessage text to display.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.message.success.use Provide ​

Replaces the success-message handler.

Signature ​

ts
use(fn: (message: string) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.success.use((message) => console.log("success", message));

Input ​

InputTypeRequired / defaultDescription
fn(message: string) => voidRequiredNew message-display function.

Returns ​

ValueTypeDescription
resultvoidNo return value; subsequent requests use the new implementation.

fastAxios.message.warning Warning ​

Calls the current warning-message handler.

Signature ​

ts
(message: string): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.warning("操作完成");

Input ​

InputTypeRequired / defaultDescription
messagestringRequiredMessage text to display.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.message.warning.use Provide ​

Replaces the warning-message handler.

Signature ​

ts
use(fn: (message: string) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.warning.use((message) => console.log("warning", message));

Input ​

InputTypeRequired / defaultDescription
fn(message: string) => voidRequiredNew message-display function.

Returns ​

ValueTypeDescription
resultvoidNo return value; subsequent requests use the new implementation.

fastAxios.message.info Info ​

Calls the current info-message handler.

Signature ​

ts
(message: string): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.info("操作完成");

Input ​

InputTypeRequired / defaultDescription
messagestringRequiredMessage text to display.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.message.info.use Provide ​

Replaces the info-message handler.

Signature ​

ts
use(fn: (message: string) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.info.use((message) => console.log("info", message));

Input ​

InputTypeRequired / defaultDescription
fn(message: string) => voidRequiredNew message-display function.

Returns ​

ValueTypeDescription
resultvoidNo return value; subsequent requests use the new implementation.

fastAxios.message.error Error ​

Calls the current error-message handler.

Signature ​

ts
(message: string): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.error("操作完成");

Input ​

InputTypeRequired / defaultDescription
messagestringRequiredMessage text to display.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.message.error.use Provide ​

Replaces the error-message handler.

Signature ​

ts
use(fn: (message: string) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.message.error.use((message) => console.log("error", message));

Input ​

InputTypeRequired / defaultDescription
fn(message: string) => voidRequiredNew message-display function.

Returns ​

ValueTypeDescription
resultvoidNo return value; subsequent requests use the new implementation.

fastAxios.loading.show Loading ​

Calls the current loading-show handler.

Signature ​

ts
(text: string): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.loading.show("加载中...");

Input ​

InputTypeRequired / defaultDescription
textstringRequiredLoading message.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.loading.show.use Provide ​

Replaces the loading-show handler.

Signature ​

ts
use(fn: (text: string) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.loading.show.use((text) => console.log("show loading", text));

Input ​

InputTypeRequired / defaultDescription
fn(text: string) => voidRequiredApplication UI show function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.loading.close Close ​

Calls the current loading-close handler.

Signature ​

ts
(options: AxiosOptions): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.loading.close({ loading: true });

Input ​

InputTypeRequired / defaultDescription
optionsAxiosOptionsRequiredCurrent Fast request options, usable for concurrency counting.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.loading.close.use Provide ​

Replaces the loading-close handler.

Signature ​

ts
use(fn: (options: AxiosOptions) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.loading.close.use((options) => console.log("close loading", options));

Input ​

InputTypeRequired / defaultDescription
fn(options: AxiosOptions) => voidRequiredApplication UI close function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.cache.get Read ​

Calls the cache reader with the request's unique key.

Signature ​

ts
(key: string): unknown;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

const result = fastAxios.cache.get("/users");

Input ​

InputTypeRequired / defaultDescription
keystringRequiredCache key generated by the request flow.

Returns ​

ValueTypeDescription
resultunknownCached value; misses should be null or undefined.

fastAxios.cache.get.use Provide ​

Replaces the cache reader.

Signature ​

ts
use(fn: (key: string) => unknown): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

const store = new Map<string, unknown>();
fastAxios.cache.get.use((key) => store.get(key));

Input ​

InputTypeRequired / defaultDescription
fn(key: string) => unknownRequiredNew cache-reading function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.cache.set Write ​

Calls the current cache writer.

Signature ​

ts
(key: string, value: unknown): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.cache.set("/users", [{ id: 1 }]);

Input ​

InputTypeRequired / defaultDescription
keystringRequiredRequest cache key.
valueunknownRequiredFinal result returned to the caller.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.cache.set.use Provide ​

Replaces the cache writer.

Signature ​

ts
use(fn: (key: string, value: unknown) => void): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

const store = new Map<string, unknown>();
fastAxios.cache.set.use((key, value) => {
	store.set(key, value);
});

Input ​

InputTypeRequired / defaultDescription
fn(key: string, value: unknown) => voidRequiredNew cache-writing function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.crypto.encrypt Encrypt ​

Calls the encryptor before sending the request.

Signature ​

ts
<Input>(config: InternalAxiosRequestConfig<Input>, timestamp: number): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

import { AxiosHeaders, type InternalAxiosRequestConfig } from "axios";

const config = { headers: new AxiosHeaders() } as InternalAxiosRequestConfig;
fastAxios.crypto.encrypt(config, Date.now());

Input ​

InputTypeRequired / defaultDescription
configInternalAxiosRequestConfig<Input>RequiredMutable Axios request configuration.
timestampnumberRequiredUnix millisecond timestamp shared by the current request.

Returns ​

ValueTypeDescription
resultvoidNo return value; the encryptor mutates config.

fastAxios.crypto.encrypt.use Provide ​

Replaces the request encryptor.

Signature ​

ts
use(fn: CryptoEncryptHandle): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.crypto.encrypt.use((config, timestamp) => {
	config.headers.set("X-Time", timestamp);
});

Input ​

InputTypeRequired / defaultDescription
fnCryptoEncryptHandleRequiredNew request encryption or signing function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.crypto.decrypt Decrypt ​

Calls the current response decryptor.

Signature ​

ts
<Output, Input>(response: AxiosResponse<Output, Input>, options: FastAxiosRequestConfig<Input>): unknown;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

import axios from "axios";

const requestOptions = { url: "/users" };
const response = await axios.request(requestOptions);
const result = fastAxios.crypto.decrypt(response, requestOptions);

Input ​

InputTypeRequired / defaultDescription
responseAxiosResponse<Output, Input>RequiredResponse that has passed RESTful status validation.
optionsFastAxiosRequestConfig<Input>RequiredCurrent Fast request options.

Returns ​

ValueTypeDescription
resultunknownComplete response body for subsequent simplified-data unwrapping.

fastAxios.crypto.decrypt.use Provide ​

Replaces the response decryptor.

Signature ​

ts
use(fn: CryptoDecryptHandle): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.crypto.decrypt.use((response) => response.data);

Input ​

InputTypeRequired / defaultDescription
fnCryptoDecryptHandleRequiredNew response decryption function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.interceptors.request Request ​

Calls the project request preprocessing handler.

Signature ​

ts
<Input>(config: InternalAxiosRequestConfig<Input>): void | Promise<void>;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

import { AxiosHeaders, type InternalAxiosRequestConfig } from "axios";

const config = { headers: new AxiosHeaders() } as InternalAxiosRequestConfig;
fastAxios.interceptors.request(config);

Input ​

InputTypeRequired / defaultDescription
configInternalAxiosRequestConfig<Input>RequiredMutable configuration of the request about to be sent.

Returns ​

ValueTypeDescription
resultvoid | Promise<void>No return value.

fastAxios.interceptors.request.use Provide ​

Replaces the project request preprocessing handler.

Signature ​

ts
use(fn: InterceptorsRequestHandle): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.interceptors.request.use((config) => {
	config.headers.set("Authorization", "Bearer token");
});

Input ​

InputTypeRequired / defaultDescription
fnInterceptorsRequestHandleRequiredNew request handler.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.interceptors.response Response ​

Calls the project success-response handler.

Signature ​

ts
<Output, Input>(response: AxiosResponse<Output, Input>, options: FastAxiosRequestConfig<Input>): unknown;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

import axios from "axios";

const requestOptions = { url: "/users" };
const response = await axios.request(requestOptions);
const result = fastAxios.interceptors.response(response, requestOptions);

Input ​

InputTypeRequired / defaultDescription
responseAxiosResponse<Output, Input>RequiredSuccessful Axios response.
optionsFastAxiosRequestConfig<Input>RequiredCurrent Fast request options.

Returns ​

ValueTypeDescription
resultunknownA non-nullish value takes over default response processing; nullish values continue it.

fastAxios.interceptors.response.use Provide ​

Replaces the project success-response handler.

Signature ​

ts
use(fn: InterceptorsResponseHandle): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.interceptors.response.use((response) => (response.headers["x-custom"] ? response.data : undefined));

Input ​

InputTypeRequired / defaultDescription
fnInterceptorsResponseHandleRequiredNew success-response handler.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.interceptors.responseError Error ​

Calls the project failed-response handler.

Signature ​

ts
<Input>(error: AxiosError<unknown, Input>, options: FastAxiosRequestConfig<Input>): unknown;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

import { AxiosError } from "axios";

const error = new AxiosError("Network Error");
const requestOptions = { url: "/users" };
const result = fastAxios.interceptors.responseError(error, requestOptions);

Input ​

InputTypeRequired / defaultDescription
errorAxiosError<unknown, Input>RequiredAxios request failure object.
optionsFastAxiosRequestConfig<Input>RequiredCurrent Fast request options.

Returns ​

ValueTypeDescription
resultunknownA non-nullish value replaces the final thrown error.

fastAxios.interceptors.responseError.use Provide ​

Replaces the project failed-response handler.

Signature ​

ts
use(fn: InterceptorsResponseErrorHandle): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.interceptors.responseError.use((error) => (error.response?.status === 401 ? new Error("登录失效") : undefined));

Input ​

InputTypeRequired / defaultDescription
fnInterceptorsResponseErrorHandleRequiredNew failed-response handler.

Returns ​

ValueTypeDescription
resultvoidNo return value.

fastAxios.messageBox.confirm Confirm ​

Opens a confirmation dialog and awaits the user's choice.

Signature ​

ts
(options: MessageBoxOptions): Promise<void>;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

await fastAxios.messageBox.confirm({ message: "确认删除?", type: "warning" });

Input ​

InputTypeRequired / defaultDescription
optionsMessageBoxOptionsRequiredBody text, type, and button labels.

Returns ​

ValueTypeDescription
resultPromise<void>Resolves on confirmation; rejects on cancellation or platform failure.

fastAxios.messageBox.confirm.use Provide ​

Replaces the confirmation handler.

Signature ​

ts
use(fn: MessageBoxHandle): void;

Example ​

ts
import { createFastAxios } from "@fast-china/axios";

const fastAxios = createFastAxios({ baseUrl: "/api" }, true);

fastAxios.messageBox.confirm.use(async (options) => {
	console.log(options.message);
});

Input ​

InputTypeRequired / defaultDescription
fnMessageBoxHandleRequiredNew asynchronous confirmation function.

Returns ​

ValueTypeDescription
resultvoidNo return value.

Cache scope and async handlers ​

Starting with 2.0.9, eligible GET requests need only cache: true; no namespace or custom key is required. The key is the endpoint path and query parameters serialized by Axios, preserving paramsSerializer output but excluding baseURL and the origin of absolute URLs, captured after the request hook but before cache-busting timestamps or encryption. Cache keys are separate from duplicate-request keys and contain no random instance prefix, generation, headers or login state. Reinitializing the SDK can reuse the same persistent entries for the same URL.

Identical paths and queries share cache entries across base URLs. Applications own cleanup of old full-URL entries and service, account, tenant, language and cookie-session isolation. cache.clear() clears the default in-memory Map and prevents in-flight old requests from writing back; it does not clear custom storage. Custom backends own physical deletion and TTL. The default cache holds at most 256 entries with a five-minute TTL and does not write to uni synchronous storage. Cache hits still execute the request hook and Axios cancellation checks, but skip Loading, decryption and response takeover.

The request pipeline awaits request, response and responseError results. Nullish async takeover results continue defaults; rejections propagate. Non-Axios errors, cancellation and explicit offline handling retain their specialized paths without responseError. Message, Loading and Crypto hooks remain synchronous. Manual invocation leaves awaiting and pairing to the caller.