Merge branch 'feature/[email protected]'

Author: JOU-amjs

docs/resource/01-request-adapter/05-uniapp.md

@@ -55,7 +55,7 @@ const alovaInst = createAlova({
 
 ### Request
 
-The usage method of the request is exactly the same as that used in the web environment. Already fully compatible with `uni.request`, you can specify [all configuration items] supported by `uni.request` in _config_ of method instance creation (https://uniapp.dcloud.net.cn/api/request/ request.html)
+The usage method of the request is exactly the same as that used in the web environment. Already fully compatible with `uni.request`, you can specify [all configuration items](https://uniapp.dcloud.net.cn/api/request/request.html) supported by `uni.request` in _config_ of method instance creation.
 
 ```html
 <template>

docs/resource/02-storage-adapter/01-psc.md

@@ -8,7 +8,7 @@ We implemented two adapters that can be used in Node.js and Electron.
 
 :::info Tips
 
-Only supports Alova 3.0 and above.
+Only alova 3.0+ is supported.
 
 :::
 

docs/resource/02-storage-adapter/02-file.md

@@ -0,0 +1,38 @@
+---
+title: File Storage Adapter
+---
+
+Store data through files, use atomic file operations, and support server clusters.
+
+:::info Tips
+
+Only alova 3.0+ is supported.
+
+:::
+
+## Installation
+
+```bash
+# npm
+npm install alova @alova/storage-file --save
+# yarn
+yarn add alova @alova/storage-file
+# npm
+pnpm install alova @alova/storage-file
+```
+
+## Usage
+
+Create `FileStorageAdapter` and specify the file storage directory. If the directory does not exist, it will be created automatically.
+
+```javascript
+const { createAlova } = require('alova');
+const FileStorageAdapter = require('@alova/storage-file');
+
+const dir = '~/alova/storage';
+const fileAdapter = new FileStorageAdapter({ directory: dir });
+const alovaInstance = createAlova({
+  // ...
+  l2Cache: fileAdapter
+});
+```

docs/resource/02-storage-adapter/03-redis.md

@@ -0,0 +1,73 @@
+---
+title: Redis Storage Adapter
+---
+
+Store data through redis and support distributed clusters. Use [ioredis](https://www.npmjs.com/package/ioredis) to implement it.
+
+:::info Tips
+
+Only alova 3.0+ is supported.
+
+:::
+
+## Installation
+
+```bash
+# npm
+npm install alova @alova/storage-redis --save
+# yarn
+yarn add alova @alova/storage-redis
+# npm
+pnpm install alova @alova/storage-redis
+```
+
+## Usage
+
+### Basic usage
+
+Create `RedisStorageAdapter` and specify the redis server connection information.
+
+```javascript
+const { createAlova } = require('alova');
+const RedisStorageAdapter = require('@alova/storage-redis');
+
+const redisAdapter = new RedisStorageAdapter({
+  host: 'localhost',
+  port: '6379',
+  username: 'default',
+  password: 'my-top-secret',
+  db: 0
+});
+const alovaInstance = createAlova({
+  // ...
+  l2Cache: redisAdapter
+});
+```
+
+### Set the storage key prefix
+
+By default, the storage key prefix is ​​`alova:`, which can be set via `keyPrefix`.
+
+```javascript
+const redisAdapter = new RedisStorageAdapter({
+  host: 'localhost',
+  port: '6379',
+  username: 'default',
+  password: 'my-top-secret',
+  db: 0,
+
+  // highlight-start
+  keyPrefix: 'my-app:'
+  // highlight-end
+});
+```
+
+### Use an external redis instance
+
+If you already have an `ioredis` instance in your project and want to use it for operations, you can set it through `client`.
+
+```javascript
+const redisAdapter = new RedisStorageAdapter({
+  client: originalRedisClient
+});
+```

docs/tutorial/02-getting-started/01-introduce.md

@@ -14,19 +14,20 @@ import TabItem from '@theme/TabItem';
 
 ## What is alova?
 
-Alova (pronounced `/əˈləʊva/`<AudioPlayer src={tts} />) is a next-generation request library that radically simplifies your API integration workflow, reducing what used to take 7 complex steps down to just 1 - simply select your API and go.
+alova​​ (pronounced /əˈləʊva/<AudioPlayer src={tts} />) is a request toolkit design for API integrating with ​​ultimate efficiency. it seamlessly works with your favorite HTTP clients and UI frameworks, accelerating business logic development for both client and server apps, while enabling interactive API information within your code. bridging the backend collaboration gap like a wormhole.
 
-Unlike libraries such as `@tanstack/react-request`, `swrjs`, and `useRequest` from `ahooks`, alova revolutionizes your development experience by wrapping `fetch/XMLHttpRequest/axios` into request adapters and providing intelligent request strategies for even the most complex scenarios.
-
-Want to dive into the origin story? Check out [Why we created alova](/about/faqs). For a deep dive into how we're different, explore our comprehensive [comparison with other request libraries](/about/comparison).
+Learn about our story in [why built alova](/about/faqs), and explore how we differ in our detailed [comparison with other request libraries](/about/comparison).
 
 ## Features
 
-- Incredibly simple to use with a minimal learning curve.
-- More modern OpenAPI solution - say goodbye to tedious intermediate API documentation.
-- Compatible with client-side technologies and request libraries: `react/vue/svelte/solid/next/nuxt/sveltkit/solid-start/uniapp/taro/...` + `fetch/XMLHttpRequest/axios/...`
-- Compatible with server-side technologies and request libraries: `nodejs/deno/bun/...` + `fetch/XMLHttpRequest/axios/...`
-- 15+ high-performance request strategies to handle complex request scenarios, helping you develop more efficient applications faster.
+- ​​Easy to use, [watching video](/video-tutorial) to get started in 5 mins.
+- ​​Full compatibility​​ with your favorite technology stack.
+- ​​20+ high-performance business modules​​ for building faster apps.
+- ​​Advanced OpenAPI solution​​ for efficient APIs information interaction within your code.
+- Request sharing and response cache to improve app performance.
+- Type safety.
+
+<SupportList showStatus></SupportList>
 
 ## Live Demo
 
@@ -414,12 +415,6 @@ With the various features of alova, you can also build a Client-Server interacti
 
 > To learn how to build a CS Interaction Layer, refer to [Building the Client-Server Interaction Layer](/tutorial/project/best-practice/csil)
 
-## Run in any JS environment
-
-alova is very flexible, you can use it with various request tools across any JavaScript environment (grayed-out options will be gradually supported in the future).
-
-<SupportList showStatus></SupportList>
-
 ## Migration Guide
 
 - [Migration from v2 to v3](/tutorial/project/migration/v2-to-v3)

docs/tutorial/02-getting-started/03-basic/07-combine-framework.md

@@ -38,7 +38,7 @@ export const alovaInstance = createAlova({
 
 </TabItem>
 
-<TabItem value="2" label="react">
+<TabItem value="2" label="react/next">
 
 ```js
 import { createAlova } from 'alova';
@@ -52,6 +52,25 @@ export const alovaInstance = createAlova({
 });
 ```
 
+</TabItem>
+<TabItem value="6" label="nuxt">
+
+```js
+import { createAlova } from 'alova';
+import NuxtHook from 'alova/nuxt';
+
+export const alovaInstance = createAlova({
+  // ...
+  // highlight-start
+  statesHook: NuxtHook({
+    nuxtApp: useNuxtApp
+  })
+  // highlight-end
+});
+```
+
+For more usage about NuxtHook，please refer to [SSR#nuxt](/tutorial/advanced/in-depth/ssr#nuxt3)
+
 </TabItem>
 <TabItem value="3" label="svelte">
 

docs/tutorial/02-getting-started/03-basic/08-server.md

@@ -23,46 +23,49 @@ On the server, we also have different request scenarios, such as request retries
 The following is an example that combines `retry` and `sendCaptcha`, which implements sending verification codes by retrying after failure:
 
 ```js
-const { retry, sendCaptcha } = require('alova/server');
+const { retry, createCaptchaProvider } = require('alova/server');
 
-const email = '[email protected]';
-// Create a method instance for sending verification codes
-const captchaMethod = alovaInstance.Post('/api/captcha', {
-  email,
-  content: 'captcha content'
+const { sendCaptcha } = createCaptchaProvider({
+  store: redisAdapter
 });
 
-// Use retry hook to wrap captchaMethod
-const retringMethod = retry(captchaMethod, {
+// step1: create a method instance to send code.
+const createCaptchaMethod = (code, key) = > alovaInstance.Post('/api/captcha', {
+  code,
+  email: key,
+});
+
+// step2: wrap `createCaptchaMethod` with sendCaptcha hook.
+const captchaMethod = sendCaptcha(createCaptchaMethod, {
+  key: '[email protected]'
+});
+
+// step3: wrap `captchaMethod` with retry hook, and get the response result through `await`
+const result = await retry(captchaMethod, {
   retry: 3,
   backoff: {
     delay: 2000
   }
 });
-// Use sendCaptcha hook to wrap retringMethod, and send the request and get the response result through await
-const result = await sendCaptcha(retringMethod, {
-  key: email
-});
 ```
 
 You can also use multiple `server hooks` to wrap method instances directly.
 
-```ts
-const result = await sendCaptcha(
-  retry(
-    alovaInstance.Post('/api/captcha', {
-      email,
-      content: 'captcha content'
-    }),
-    {
-      retry: 3,
-      backoff: {
-        delay: 2000
-      }
-    }
+```javascript
+const result = await retry(
+  sendCaptcha(
+    (code, key) =>
+      alovaInstance.Post('/api/captcha', {
+        email,
+        content: 'captcha content'
+      }),
+    { key: '[email protected]' }
   ),
   {
-    key: email
+    retry: 3,
+    backoff: {
+      delay: 2000
+    }
   }
 );
 ```