wok-server 0.2.2 → 0.3.1

package/dist/mvc/static/static-handler.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticHandler = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const zlib_1 = require("zlib");
+const render_1 = require("../render");
+const header_1 = require("./header");
+const mime_type_1 = require("./mime-type");
+const server_cache_1 = require("./server-cache");
+const server_cache_config_1 = require("./server-cache-config");
+class StaticHandler {
+    DEFAULT_CONTENT_TYPE = 'application/octet-stream';
+    maxFileSize;
+    cache;
+    rules;
+    /**
+     * 静态处理器。规则说明：
+     * 请求路径仅支持前缀匹配，不支持通配符，比如 /a/demo.html 可以匹配 /a 路径，响应配置的文件目录下的 demo.html 文件。
+     * 路径配置是有优先级的，如果访问 /a/b/music.mp3 则会匹配到 /a/b 的配置，而不是 /a ，因为 /a/b 的配置更详细，优先级也更高，
+     * 并且如果从 /a/b 配置的目录下没有找到文件，也不会再尝试 /a 的配置。
+     *
+     * 静态文件同时也支持主页自动映射，比如访问 /a/b/c ，会匹配到 /a/b 的配置，然后在配置的文件目录下寻找文件 c ，
+     * 如果找不到则尝试寻找目录 c 下的 index.html 文件。
+     * @param rules 规则设置
+     */
+    constructor(rules) {
+        const config = (0, server_cache_config_1.getConfig)();
+        this.maxFileSize = (0, server_cache_config_1.parseSize)(config.maxFileSize);
+        if (config.enable) {
+            this.cache = new server_cache_1.ServerCache({ maxSize: (0, server_cache_config_1.parseSize)(config.maxSize), maxAge: config.maxAge });
+        }
+        this.rules = [];
+        // 规则解析，路径判定，设置的目录必须存在或可以被创建
+        // 重复记录表 ，作用是为了路径去重判定，可以提示哪些路径是重复的
+        const duplicateMap = new Map();
+        for (const entry of Object.entries(rules)) {
+            const [path, setting] = entry;
+            const dir = (0, path_1.isAbsolute)(setting.dir) ? setting.dir : (0, path_1.resolve)(process.cwd(), setting.dir);
+            if (!(0, fs_1.existsSync)(dir)) {
+                throw new Error(`Static file configuration error，path ${dir} does not exist，config dir：${setting.dir}`);
+            }
+            const statRes = (0, fs_1.statSync)(dir);
+            if (!statRes.isDirectory()) {
+                throw new Error(`Static file configuration error，path ${dir} is not a directory，config dir：${setting.dir}`);
+            }
+            let finalPath = path.startsWith('/') ? path : '/' + path;
+            // 保持以 / 结尾，为了匹配方便
+            if (!finalPath.endsWith('/')) {
+                finalPath += '/';
+            }
+            if (duplicateMap.has(finalPath)) {
+                throw new Error(`Static path duplicated: ${duplicateMap.get(finalPath)} and ${path}`);
+            }
+            duplicateMap.set(finalPath, path);
+            this.rules.push({ path: finalPath, dir, cacheAge: setting.cacheAge || 0 });
+        }
+        // 优先级排序
+        this.rules.sort((o1, o2) => {
+            let priority1 = o1.path === '/' ? -1 : o1.path.split('/').length;
+            let priority2 = o2.path === '/' ? -1 : o2.path.split('/').length;
+            // 如果 o1 优先级高，就应该排前面，返回小于0的值，反之亦然\
+            // 前面的优先级值是值越大优先级越高，反过来减
+            return priority2 - priority1;
+        });
+    }
+    /**
+     * 处理静态文件 get 请求
+     * @param request
+     * @param response
+     * @param path
+     * @returns 是否能够处理，如果因为找不到文件或其它原因无法处理则返回 false ，由后续流程继续处理
+     */
+    async handleGet(request, response, path) {
+        // 解析消息头
+        const headersInfo = (0, header_1.parseHeaders)(request.headers);
+        // 构建文件信息
+        let file = await this.buildRespFile(path, headersInfo);
+        if (!file) {
+            return false;
+        }
+        // content-type
+        response.setHeader('Content-Type', file.mimeType);
+        // client cache
+        if (file.maxAge === 0) {
+            response.setHeader('Cache-Control', 'no-store');
+        }
+        else if (file.maxAge) {
+            response.setHeader('Cache-Control', `max-age=${file.maxAge}`);
+        }
+        response.setHeader('Last-Modified', file.mtime.toUTCString());
+        // 开始响应，先判定 if-modified-since
+        if (headersInfo.ifModifiedSince) {
+            if (headersInfo.ifModifiedSince >= file.mtime) {
+                response.statusCode = 304;
+                response.end();
+                return true;
+            }
+        }
+        if (headersInfo.range) {
+            const { start } = headersInfo.range;
+            if (isNaN(start) || start < 0) {
+                (0, render_1.renderError)(response, `Range not satisfiable，start is ${start}.`, 416);
+                return true;
+            }
+            const maxEnd = file.size - 1;
+            let end = headersInfo.range.end ? headersInfo.range.end : maxEnd;
+            // 校验 end
+            if (end <= start) {
+                (0, render_1.renderError)(response, `Range not satisfiable，end must be greater than start.`, 416);
+                return true;
+            }
+            if (end > maxEnd) {
+                (0, render_1.renderError)(response, `Range not satisfiable，end must not be greater than ${maxEnd}.`, 416);
+                return true;
+            }
+            // range 是前后都包含的，详细可以参考规范：
+            // https://www.rfc-editor.org/rfc/rfc9110#field.range
+            // 但是 buffer.subarray 中包含前不包含后，createReadStream 是前后都包含的，需要注意
+            // 还需要注意 gzip 编码
+            response.setHeader('Content-Range', `bytes ${start}-${end}/${file.size}`);
+            response.statusCode = 206;
+            if (file.bufferOrPath instanceof Buffer) {
+                let buffer = file.bufferOrPath.subarray(start, end + 1);
+                if (headersInfo.gzip) {
+                    buffer = await new Promise((resolve, reject) => {
+                        (0, zlib_1.gzip)(buffer, (err, res) => {
+                            if (err) {
+                                reject(err);
+                                return;
+                            }
+                            resolve(res);
+                        });
+                    });
+                    response.setHeader('Content-Encoding', 'gzip');
+                }
+                await this.endRespWithBuffer(response, buffer);
+            }
+            else {
+                const filePath = file.bufferOrPath;
+                // 文件处理
+                await new Promise((resolve, reject) => {
+                    response.setHeader('Content-Encoding', 'gzip');
+                    response.once('finish', resolve).once('error', reject);
+                    if (headersInfo.gzip) {
+                        (0, fs_1.createReadStream)(filePath, { start, end }).pipe((0, zlib_1.createGzip)()).pipe(response);
+                    }
+                    else {
+                        (0, fs_1.createReadStream)(filePath, { start, end }).pipe(response);
+                    }
+                });
+            }
+            return true;
+        }
+        // gzip
+        if (headersInfo.gzip) {
+            response.setHeader('Content-Encoding', 'gzip');
+            if (file.bufferOrPath instanceof Buffer) {
+                // buffer 是缓存的文件，gzip 编码缓存的文件即是已经压缩后的文件
+                await this.endRespWithBuffer(response, file.bufferOrPath);
+            }
+            else {
+                (0, fs_1.createReadStream)(file.bufferOrPath).pipe((0, zlib_1.createGzip)()).pipe(response);
+            }
+            return true;
+        }
+        // 普通的整个文件请求处理
+        if (file.bufferOrPath instanceof Buffer) {
+            await this.endRespWithBuffer(response, file.bufferOrPath);
+        }
+        else {
+            const filePath = file.bufferOrPath;
+            await new Promise((resolve, reject) => {
+                response.once('finish', resolve).once('error', reject);
+                (0, fs_1.createReadStream)(filePath).pipe(response);
+            });
+        }
+        return true;
+    }
+    /**
+     *  处理 head 请求，不响应正文内容，如果文件可以被找到，仅仅响应以下的消息头：
+     * Content-Length
+     * Content-Type
+     * Last-Modified
+     * Cache-Control
+     *
+     * @param path 请求路径
+     * @param response
+     * @returns 是否成功处理
+     */
+    async handleHead(path, response) {
+        // 构建文件信息
+        let file = await this.buildRespFile(path, { gzip: false });
+        if (!file) {
+            return false;
+        }
+        response.setHeader('Content-Length', file.size);
+        response.setHeader('Content-Type', file.mimeType);
+        response.setHeader('Last-Modified', file.mtime.toUTCString());
+        if (file.maxAge === 0) {
+            response.setHeader('Cache-Control', 'no-store');
+        }
+        else if (file.maxAge) {
+            response.setHeader('Cache-Control', `max-age=${file.maxAge}`);
+        }
+        response.end();
+        return true;
+    }
+    async endRespWithBuffer(response, buffer) {
+        await new Promise((resolve, reject) => {
+            response.write(buffer, err => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        await new Promise((resolve, reject) => {
+            response.end(resolve);
+        });
+    }
+    /**
+     * 构建响应文件
+     *
+     * @param path
+     * @param headers
+     * @returns
+     */
+    async buildRespFile(path, headers) {
+        if (!this.cache) {
+            const file = await this.findFile(path);
+            if (!file) {
+                return null;
+            }
+            let { mtime } = file.stats;
+            mtime.setMilliseconds(0);
+            return {
+                maxAge: file.maxAge,
+                mtime: mtime,
+                size: file.stats.size,
+                bufferOrPath: file.filePath,
+                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
+            };
+        }
+        const cacheingGzip = headers.gzip && !headers.range;
+        const key = cacheingGzip ? `gzip-${path}` : path;
+        let file;
+        const cachedVal = await this.cache.computeIfAbsent(key, async () => {
+            file = (await this.findFile(path)) || undefined;
+            if (!file) {
+                return null;
+            }
+            // 文件太大不能被缓存
+            if (file.stats.size > this.maxFileSize) {
+                return null;
+            }
+            let buffer = await (0, promises_1.readFile)(file.filePath);
+            // gzip 存储压缩后的文件
+            if (cacheingGzip) {
+                buffer = await new Promise((resolve, reject) => {
+                    (0, zlib_1.gzip)(buffer, (err, res) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve(res);
+                        }
+                    });
+                });
+            }
+            let { mtime } = file.stats;
+            mtime.setMilliseconds(0);
+            return {
+                buffer,
+                mtime: mtime,
+                cacheAge: file.maxAge,
+                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
+            };
+        });
+        if (cachedVal) {
+            return {
+                maxAge: cachedVal.cacheAge,
+                mtime: cachedVal.mtime,
+                size: cachedVal.buffer.length,
+                bufferOrPath: cachedVal.buffer,
+                mimeType: cachedVal.mimeType
+            };
+        }
+        // 判定文件大小
+        if (file) {
+            let { mtime } = file.stats;
+            mtime.setMilliseconds(0);
+            return {
+                maxAge: file.maxAge,
+                mtime: mtime,
+                size: file.stats.size,
+                bufferOrPath: file.filePath,
+                mimeType: (0, mime_type_1.decideContentType)(file.filePath) || this.DEFAULT_CONTENT_TYPE
+            };
+        }
+        return null;
+    }
+    /**
+     * 根据路径查找文件
+     * @param path 访问路径
+     * @returns 返回被查询到的文件信息，如果找不到则返回 null
+     */
+    async findFile(path) {
+        let matchedRule;
+        for (const rule of this.rules) {
+            if (rule.path === '/') {
+                matchedRule = rule;
+                break;
+            }
+            if (path.startsWith(rule.path)) {
+                matchedRule = rule;
+                break;
+            }
+        }
+        // 匹配失败
+        if (!matchedRule) {
+            return null;
+        }
+        // 构建地址
+        let finalPath = matchedRule.path === '/' ? path : path.substring(matchedRule.path.length);
+        if (finalPath.startsWith('/')) {
+            finalPath = finalPath.substring(1);
+        }
+        let filePath = (0, path_1.resolve)(matchedRule.dir, finalPath);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return null;
+        }
+        const fileStat = await (0, promises_1.stat)(filePath);
+        // 如果是目录，尝试查找 index.html
+        if (fileStat.isDirectory()) {
+            const indexPath = (0, path_1.resolve)(filePath, 'index.html');
+            if (!(0, fs_1.existsSync)(indexPath)) {
+                return null;
+            }
+            const indexStat = await (0, promises_1.stat)(indexPath);
+            if (!indexStat.isFile()) {
+                return null;
+            }
+            return { filePath: indexPath, stats: indexStat };
+        }
+        if (!fileStat.isFile()) {
+            return null;
+        }
+        return { filePath, stats: fileStat, maxAge: matchedRule.cacheAge };
+    }
+}
+exports.StaticHandler = StaticHandler;

package/dist/mysql/manager/ops/update.js

@@ -65,6 +65,16 @@ function updatorToSql(table, updater) {
             continue;
         }
         const val = updater[column];
+        // undefined 表示不参与更新，作用是方便编写一些特殊的逻辑，比如特定情况下不更新
+        if (val === undefined) {
+            continue;
+        }
+        // 兼容将值设置成 null 的情况，和 ['setNull’] 等同
+        if (val === null) {
+            updateFragList.push(' ?? = NULL ');
+            values.push(column);
+            continue;
+        }
         if (Array.isArray(val)) {
             // set null
             if (val[0] === 'setNull') {
@@ -77,7 +87,11 @@ function updatorToSql(table, updater) {
                 values.push(column, column, val[1]);
                 continue;
             }
-            continue;
+            if (val[0] === 'set') {
+                updateFragList.push(' ?? = ? ');
+                values.push(column, (0, utils_2.processColumnValue)(val[1]));
+                continue;
+            }
         }
         updateFragList.push(' ?? = ? ');
         values.push(column, (0, utils_2.processColumnValue)(val));

package/dist/validation/index.js

@@ -18,7 +18,18 @@ function validate(obj, opts) {
                 if (result.propPath) {
                     propPath.push(...result.propPath);
                 }
-                throw new exception_1.ValidationException(result.message, result.validator, propPath.join('.'), val);
+                const fullPath = propPath
+                    .map((prop, idx) => {
+                    if (idx === 0) {
+                        return prop;
+                    }
+                    if (prop.startsWith('[') && prop.endsWith(']')) {
+                        return prop;
+                    }
+                    return '.' + prop;
+                })
+                    .join('');
+                throw new exception_1.ValidationException(result.message, result.validator, fullPath, val);
             }
         }
     }

package/dist/validation/validator/array.js

@@ -17,18 +17,14 @@ function array(opts) {
         // 条目处理
         for (let i = 0; i < val.length; i++) {
             const item = val[i];
-            for (const validation of Object.entries(opts)) {
-                const [prop, validators] = validation;
-                const val = item[prop];
-                for (const validate of validators) {
-                    const result = validate(val);
-                    if (!result.ok) {
-                        const propPath = [`[${i}]`, prop];
-                        if (result.propPath) {
-                            propPath.push(...result.propPath);
-                        }
-                        return { ok: false, validator, message: result.message, propPath };
+            for (const validation of opts) {
+                const result = validation(item);
+                if (!result.ok) {
+                    const propPath = [`[${i}]`];
+                    if (result.propPath) {
+                        propPath.push(...result.propPath);
                     }
+                    return { ok: false, validator, message: result.message, propPath };
                 }
             }
         }

package/dist/validation/validator/min.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.min = void 0;
 const i18n_1 = require("../../i18n");
 /**
- * 最大值校验.
- * @param max 最大值
+ * 最小值校验.
+ * @param min 最小值
  * @param msg 错误消息
  */
 function min(min, msg) {

package/documentation/zh-cn/config.md

@@ -9,6 +9,28 @@
 | :------------- | :--------------------------------------------------------------- |
 | registerConfig | 注册配置信息，注册会立即匹配环境变量并返回映射了属性后的配置对象 |
 | getConfig      | 获取配置信息                                                     |
+| registerConfig | 根据环境变量生成配置信息，但是不注册                             |
+
+## 配置类型和实例对象
+
+要进行配置映射，首先要定义一个配置类型，下面是一个例子：
+
+```ts
+/**
+ * 配置定义
+ */
+interface CustomConfig {
+  appId: string
+  appSecret: string
+}
+```
+
+**配置类型的所有属性都不能是可空的，必须有值，这样才可以映射。**
+当然也可以不定义类型，直接申明一个对象，调用 registerConfig 也可以完成类型的自动推断，见后面 registerConfig 的说明。
+
+配置对象的目前仅支持下列类型：string、number、boolean。
+
+## registerConfig
 
 环境变量的映射需要有一个前缀，然后将对象的属性拼接前缀，再进行转换，去匹配环境变量。
 比如配置对象有个属性是 appId，设置的前缀是 cus ，那么匹配的环境变量就是 CUS_APP_ID。
@@ -60,9 +82,18 @@ const config2 = registerConfig(
 )
 ```
 
+## getConfig
+
 getConfig 函数仅一个参数，传递前缀，可以获取到配置对象。
 一般很少需要使用，推荐调用 registerConfig 时将返回的配置对象导出以供其它程序模块使用。
 
 ```ts
 const config2 = getConfig('c2')
 ```
+
+## generateConfig
+
+根据环境变量来生成配置对象，与 registerConfig 的参数是一致的，和 registerConfig 不同的是
+generateConfig 可以多次重复使用，方便在运行时更改环境变量后再生成配置，而调用 registerConfig
+一旦注册后不能再被更改。之所以这样设计是为了方便程序的测试，模拟在不同的环境下运行程序，
+和其它的一些特殊需求。

package/documentation/zh-cn/mvc.md

@@ -275,6 +275,40 @@ export const userCreateHandler = createJsonHandler<Form, Resp>({
 
 校验时会自动根据消息头 `accept-language` 切换校验器的语言，对于没有自定义错误信息的校验使用切换后的语言给予默认的提示。
 
+从 0.3.0 版本开始，createJsonHandler 支持了通过 cache 选项来设置使用缓存组件将响应结果进行缓存，
+在可以复用缓存的情况下，避免再次执行整个 handle 方法的流程，从而提升性能。
+
+```ts
+export const userGetHandler = createJsonHandler<Form, User>({
+  // 设置缓存，参数和 handle 方法一样的
+  // 只能缓存有效的响应信息，如果没有响应正文则不会进行缓存
+  async cache(body, exchange) {
+    // 使用参数 id 来构建缓存的 key
+    const key = `get-user-${body.id}`
+    // 返回缓存的 key 和有效时间，有效时间是可选的
+    return { key, expiresInSeconds: 60 }
+  },
+  async handle(body, exchange) {
+    // handle 流程省略 ...
+  }
+})
+```
+
+由于缓存是基于缓存组件，那么也可以通过缓存组件来清理缓存。
+
+```ts
+export const userUpdateHandler = createJsonHandler<Form>({
+  async handle(body, exchange) {
+    // handle 部分流程省略 ...
+    // 将用户详情接口的缓存清理掉
+    getCache().remove(`get-user-${body.id}`)
+  }
+})
+```
+
+但是不要使用缓存组件来获取缓存内容，因为为了提升性能，缓存的内容是 Bufer，
+当使用缓存时避免再次执行对象序列化，并不是 handle 方法返回的对象。
+
 ### 二进制（Binary）上传
 
 二制进上传也就是将文件以二进制的形式写入请求正文，请求正文仅存储文件内容没有别的信息，
@@ -534,6 +568,20 @@ dir 参数是映射文件目录的地址，可以是绝对路径，也可以是
 静态文件同时也支持主页自动映射，比如访问 /a/b/c ，会匹配到 /a/b 的配置，然后在配置的文件目录下寻找文件 c ，
 如果找不到则尝试寻找目录 c 下的 index.html 文件。
 
+#### 静态文件服务器缓存
+
+从 0.3.0 版本开始，支持服务器端缓存静态文件。要启用静态文件缓存，需要配置以下的环境变量：
+
+| 环境变量                          | 说明                                                              |
+| :-------------------------------- | :---------------------------------------------------------------- |
+| SERVER_STATIC_CACHE_ENABLE        | 是否启用服务器缓存，默认 false                                    |
+| SERVER_STATIC_CACHE_MAX_AGE       | 服务器缓存时间，单位秒，默认 600                                  |
+| SERVER_STATIC_CACHE_MAX_FILE_SIZE | 最大可缓存的文件大小，支持语义化格式，如 10m 和 100k 等，默认 10m |
+| SERVER_STATIC_CACHE_MAX_SIZE      | 缓存最大空间，一旦超出将执行清理，同上支持语义化格式，默认 100,   |
+
+静态文件的服务器缓存不支持清除，只能等待过期，或者空间满被清理掉。所以，只适合缓存长期不需要改变的文件，
+目前还没有支持按规则来缓存，后续的版本有可能会考虑。
+
 ### 请求日志
 
 通过将环境变量 SERVER_ACCESS_LOG 设置为 true 可以开启请求日志，开启后会在每次响应完成后输出请求和响应信息到日志里，默认是关闭的。

package/documentation/zh-cn/mysql.md

@@ -406,6 +406,78 @@ await mananger.find({
 json_extract 和 json_length 查询都需要传递元组，第一个参数就是查询的类型，第二个参数是字段名称，
 json_extract 还有第三个参数是属性路径。属性路径的格式和 js 获取属性的语法是一样的，只是用 $ 来指代字段的值。
 
+```ts
+// 批量修改出题人 id 为 x333 的记录
+await mananger.updateMany({
+  table: tableQuestion,
+  query: c => c.eq(['json_extract', 'question_setter', '$.id'], 'x333'),
+  updater: {
+    // 更新 question_setter 信息
+    question_setter: { id: 'x333', name: '李帅' }
+  }
+})
+```
+
+更新目前并没有支持 json_set 等函数，无法做到只更新 json 字段中的部分信息，只能整个更新。
+这类的操作使用的较少，后续的版本再考虑要不要支持。
+
+### 特殊修改操作
+
+partialUpdate 和 updateMany 方法支持局部修改一些字段，并且支持一些特殊的修改操作，比如自增和置空。
+
+```ts
+await manager.updateMany(tableUser, c => c.between('balance', 23, 24), {
+  // 将 balance 增加 2
+  balance: ['inc', 2],
+  // 将 consume_type 置空
+  consume_type:['setNull']
+})
+```
+
+如果将一个字段的值设置为 null 也可以置空，但是这要求设置 ts 类型支持。
+
+```ts
+interface User {
+  id: string
+  // 将 role 的类型设置包含 null
+  role: string | null
+}
+
+await manager.partialUpdate(tableUser, {
+  id: '001',
+  // 等同于 role:['setNull']
+  role: null
+})
+```
+
+之所以采用使用特殊的数组来这种方式，主要目的是为了方便，不必引入新的类型，代码编写方便。
+**但是，在引入 json 类型后，如果 json 字段是数组就可能会和特殊修改操作有冲突，**
+**比如将 json 字段的值设置为 ['setNull']，和置空操作是一样的，最终会被认为要置空字段**。
+
+```ts
+// record 实体定义
+interface Record {
+  id: string
+  // extra 字段是一个 json 数组
+  extra: string[]
+}
+await manager.partialUpdate(tableRecord, {
+  id: '001',
+  // 这样操作会被认为要将 extra 置空
+  extra: ['setNull']
+})
+```
+
+组件提供了 set 操作来解决冲突，也是一个特殊的数组，第一个元素是 'set'，第二个元素是要设置的值。
+
+```ts
+await manager.partialUpdate(tableRecord, {
+  id: '001',
+  // 这样就可以将 extra 设置为 ['setNull']
+  extra: ['set',['setNull']]
+})
+```
+
 
 ### 预编译 sql
 

package/documentation/zh-cn/validate.md

@@ -32,8 +32,6 @@ validate(
 | array       | 数组校验,设置元素对象的校验规则来校验每一个元素      |
 | plainObject | 对象校验,如果属性是对象可进一步校验属性值的属性      |
 
-**注意: array 和 plainObject 在校验层级深的对象时,可能无法拥有准确的类型推断,必须在使用这两个函数时指定泛型,比如 `plainObject<User>({...})`，否则编译会报错。**
-
 下面是对象和数组嵌套的校验示例。
 
 ```ts
@@ -66,19 +64,27 @@ validate<User>(
       })
     ],
     tags: [
-      array({
-        id: [notBlank()],
-        name: [notBlank()],
-        permissinos: [
-          notNull(),
-          // 这里无法自动进行推断类型，必须指定类型，否则编译会有错误
-          // 层级过深就必须指定泛型
-          plainObject<{ edit?: boolean; read?: boolean }>({
-            edit: [notNull()],
-            read: [notNull()]
-          })
-        ]
-      })
+      // 标签不得超过5个
+      maxLength(5),
+      // 标签列表不能为空
+      notNull(),
+      // 校验标签数组的元素
+      array([
+        // 元素不能为空
+        notNull(),
+        // 元素的属性校验
+        plainObject({
+          id: [notBlank()],
+          name: [notBlank()],
+          permissinos: [
+            notNull(),
+            plainObject({
+              edit: [notNull()],
+              read: [notNull()]
+            })
+          ]
+        })
+      ])
     ]
   }
 )