@maiyunnet/kebab 9.19.1 → 9.20.1

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "9.19.1";
+export declare const VER = "9.20.1";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 /** --- 框架的 LIB，以 / 结尾 --- */

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '9.19.1';
+export const VER = '9.20.1';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/s3.d.ts

@@ -3,8 +3,8 @@
  * Date: 2024-2-18 18:32:45
  * Last: 2024-2-18 18:32:47, 2024-3-16 16:42:27, 2024-5-31 21:36:26, 2024-7-8 00:28:42, 2024-7-19 11:32:43, 2025-6-10 21:45:34, 2025-12-5 23:42:59
  */
-import * as s3 from '@aws-sdk/client-s3';
 import * as stream from 'stream';
+import * as s3 from '@aws-sdk/client-s3';
 import * as sCtr from '#kebab/sys/ctr.js';
 /**
  * --- s3 文档：https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/s3/ ---
@@ -76,18 +76,28 @@ export declare class S3 {
      */
     setBucket(bucket: string): void;
     /**
-     * --- 上传对象（可传流且也可无需设置 length） --
+     * --- 上传对象，流内容可省略 length ---
      * @param key 对象路径
      * @param content 内容
-     * @param length 设置 contentLength，如果是流模式则需要设置此项，也可以设置为对象参数
+     * @param length contentLength 或上传选项
      * @param bucket bucket 名
+     * @returns 上传结果，失败或取消返回 false；传入 signal 时，返回前会尝试清理已知的未完成分片
      */
     putObject(key: string, content: string | Buffer | stream.Readable, length?: number | {
+        /** --- contentLength，流内容可省略 --- */
         'length'?: number;
         /** --- content-type，如 application/javascript --- */
         'type'?: string;
+        /** --- content-disposition，如 attachment --- */
         'disposition'?: string;
+        /** --- bucket 名，省略时使用预定义 bucket --- */
         'bucket'?: string;
+        /**
+         * --- 取消上传请求并销毁输入流，等待已知的未完成分片清理后返回 false ---
+         * --- 清理使用独立的 30 秒超时信号，失败时记录错误；不传则沿用原上传流程 ---
+         * --- 不删除同名对象，上传完成与取消同时发生时，由调用方清理独立任务文件 ---
+         */
+        'signal'?: AbortSignal;
     }, bucket?: string): Promise<s3.CompleteMultipartUploadCommandOutput | false>;
     /**
      * --- 批量上传对象，并发控制，单次失败不影响其他项 ---

package/lib/s3.js

@@ -4,6 +4,7 @@
  * Last: 2024-2-18 18:32:47, 2024-3-16 16:42:27, 2024-5-31 21:36:26, 2024-7-8 00:28:42, 2024-7-19 11:32:43, 2025-6-10 21:45:34, 2025-12-5 23:42:59
  */
 // --- 库和定义 ---
+import * as stream from 'stream';
 import * as s3 from '@aws-sdk/client-s3';
 import * as ls from '@aws-sdk/lib-storage';
 import * as lCore from '#kebab/lib/core.js';
@@ -67,28 +68,79 @@ export class S3 {
         this._bucket = bucket;
     }
     /**
-     * --- 上传对象（可传流且也可无需设置 length） --
+     * --- 上传对象，流内容可省略 length ---
      * @param key 对象路径
      * @param content 内容
-     * @param length 设置 contentLength，如果是流模式则需要设置此项，也可以设置为对象参数
+     * @param length contentLength 或上传选项
      * @param bucket bucket 名
+     * @returns 上传结果，失败或取消返回 false；传入 signal 时，返回前会尝试清理已知的未完成分片
      */
     async putObject(key, content, length, bucket) {
+        /** --- 对象内容类型 --- */
+        let type;
+        /** --- 对象下载方式 --- */
+        let disposition;
+        /** --- 调用方传入的取消信号，仅作用于本次上传 --- */
+        let signal;
+        if (typeof length !== 'number') {
+            type = length?.type;
+            disposition = length?.disposition;
+            bucket = length?.bucket;
+            signal = length?.signal;
+            length = length?.length;
+        }
+        bucket ??= this._bucket;
+        /** --- 输入流，传入 signal 时在取消或失败后停止读取；字符串与 Buffer 无需释放 --- */
+        const source = content instanceof stream.Readable ? content : undefined;
+        /**
+         * --- 停止流读取，避免取消时仍阻塞在等待下一块数据的阶段 ---
+         * @returns 无返回值
+         */
+        const onAbort = () => {
+            source?.destroy();
+        };
+        /** --- 尚未确认合并或清理完成的分片上传 ID，用于失败后的兜底清理 --- */
+        let uploadId;
+        /** --- 是否取得有效上传结果，失败时需要释放输入流 --- */
+        let success = false;
+        /** --- 分片清理请求的超时毫秒数，避免清理阶段无限等待 --- */
+        const cleanupTimeout = 30000;
         try {
-            /** --- content type --- */
-            let type = undefined;
-            /** --- content disposition --- */
-            let disposition = undefined;
-            if (typeof length !== 'number') {
-                type = length?.type;
-                disposition = length?.disposition;
-                bucket = length?.bucket;
-                length = length?.length;
+            if (signal?.aborted) {
+                return false;
             }
+            signal?.addEventListener('abort', onAbort, { 'once': true });
+            /** --- 本次上传的客户端入口，共享连接配置但不修改共享客户端的 send --- */
+            const client = signal ? Object.create(this._link) : this._link;
+            if (signal) {
+                /**
+                 * --- 为上传命令传递取消信号，并跟踪未完成的分片上传 ---
+                 * --- Upload.abort() 会提前结束 done()，且不会取消正在发送的请求 ---
+                 * --- 逐条命令传入信号，让 done() 等待分片任务和清理结束 ---
+                 * @param command SDK 上传或分片清理命令；Upload 仅使用 send 的 Promise 调用形式
+                 * @returns SDK 命令结果
+                 */
+                client.send = (async (command) => {
+                    /** --- 清理请求必须使用独立信号，避免随上传请求一起取消 --- */
+                    const isCleanup = command instanceof s3.AbortMultipartUploadCommand;
+                    /** --- 命令成功后再更新分片 ID，失败时保留 ID 供 finally 重试清理 --- */
+                    const res = await this._link.send(command, {
+                        'abortSignal': isCleanup ? AbortSignal.timeout(cleanupTimeout) : signal,
+                    });
+                    if (command instanceof s3.CreateMultipartUploadCommand) {
+                        uploadId = res.UploadId;
+                    }
+                    else if (isCleanup || (command instanceof s3.CompleteMultipartUploadCommand)) {
+                        uploadId = undefined;
+                    }
+                    return res;
+                });
+            }
+            /** --- SDK 上传任务，继续由 SDK 管理分片和并发 --- */
             const upload = new ls.Upload({
-                'client': this._link,
+                'client': client,
                 'params': {
-                    'Bucket': bucket ?? this._bucket,
+                    'Bucket': bucket,
                     'Key': key,
                     'Body': content,
                     'ContentLength': length,
@@ -96,13 +148,40 @@ export class S3 {
                     'ContentDisposition': disposition,
                 }
             });
+            /** --- 上传结果；取消与上传完成同时发生时仍向调用方返回 false --- */
             const res = await upload.done();
-            return (res.Location && res.Bucket && res.Key) ? res : false;
+            if (signal?.aborted || !res.Location || !res.Bucket || !res.Key) {
+                return false;
+            }
+            success = true;
+            return res;
         }
         catch (e) {
-            lCore.log(this._ctr, '[LIB][S3][putObject] ' + lText.stringifyJson(e.message ?? '').slice(1, -1).replace(/"/g, '""'), '-error');
+            if (!signal?.aborted) {
+                lCore.log(this._ctr, `[LIB][S3][putObject] ${lText.stringifyError(e)}`, '-error');
+            }
             return false;
         }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            if (signal && !success) {
+                source?.destroy();
+            }
+            // --- SDK 的合并失败分支不会清理分片；SDK 清理失败时也保留 ID，在这里兜底 ---
+            // --- 只清理本次未完成的分片，不删除可能已存在的同名对象 ---
+            if (uploadId) {
+                try {
+                    await this._link.send(new s3.AbortMultipartUploadCommand({
+                        'Bucket': bucket,
+                        'Key': key,
+                        'UploadId': uploadId,
+                    }), { 'abortSignal': AbortSignal.timeout(cleanupTimeout) });
+                }
+                catch (e) {
+                    lCore.log(this._ctr, `[LIB][S3][putObject][cleanup] ${lText.stringifyError(e)}`, '-error');
+                }
+            }
+        }
     }
     /**
      * --- 批量上传对象，并发控制，单次失败不影响其他项 ---

package/lib/sql.d.ts

@@ -10,6 +10,8 @@ export declare enum ESERVICE {
     'MYSQL' = 0,
     'PGSQL' = 1
 }
+/** --- 非空游标值；大整数和日期请使用数据库可比较的字符串 --- */
+export type TCursorValue = string | number;
 /** --- JSON 查询操作符 --- */
 export declare enum EJSON {
     /** --- 包含值 (MySQL: JSON_CONTAINS, PG: @>) --- */
@@ -209,6 +211,15 @@ export declare class Sql {
      * @param d 排序规则
      */
     by(c: string | Array<string | string[]>, d?: 'DESC' | 'ASC'): this;
+    /**
+     * --- 按非空、同向排序字段定位游标并设置排序；字段组合须唯一且有匹配索引 ---
+     * --- 使用行比较，让 PostgreSQL 可以从复合索引边界开始扫描 ---
+     * @param c 排序字段，支持表别名；不支持表达式、GROUP BY 或 UNION
+     * @param values 上一页末行的字段值，省略时读取首批
+     * @param d 扫描方向；读取前一批时反转方向并在取回后反转列表
+     * @returns 当前 SQL 对象
+     */
+    seek(c: string | string[], values?: TCursorValue[], d?: 'DESC' | 'ASC'): this;
     /**
      * --- GROUP BY ---
      * @param c 字段字符串或数组
@@ -230,6 +241,10 @@ export declare class Sql {
      */
     copy(f?: string | string[], opt?: {
         'where'?: string | kebab.Json;
+        /** --- false 时移除本查询的排序，不修改子查询 --- */
+        'order'?: false;
+        /** --- false 时移除本查询的 LIMIT/OFFSET，不修改子查询 --- */
+        'limit'?: false;
     }): Sql;
     /**
      * --- 获取 sql 语句 ---

package/lib/sql.js

@@ -55,6 +55,7 @@ export class Sql {
         this._service = opt.service ?? ESERVICE.MYSQL;
         if (opt.data) {
             this._data = opt.data;
+            this._placeholderCounter = opt.data.length + 1;
         }
         if (opt.sql) {
             this._sql = opt.sql;
@@ -770,6 +771,54 @@ export class Sql {
         this._sql.push(sql);
         return this;
     }
+    /**
+     * --- 按非空、同向排序字段定位游标并设置排序；字段组合须唯一且有匹配索引 ---
+     * --- 使用行比较，让 PostgreSQL 可以从复合索引边界开始扫描 ---
+     * @param c 排序字段，支持表别名；不支持表达式、GROUP BY 或 UNION
+     * @param values 上一页末行的字段值，省略时读取首批
+     * @param d 扫描方向；读取前一批时反转方向并在取回后反转列表
+     * @returns 当前 SQL 对象
+     */
+    seek(c, values, d = 'DESC') {
+        const fields = typeof c === 'string' ? [c] : c;
+        if (!fields.length || new Set(fields).size !== fields.length ||
+            fields.some(field => !/^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$/.test(field)) ||
+            !['ASC', 'DESC'].includes(d)) {
+            throw new Error('Invalid cursor ordering');
+        }
+        if (this._sql.some(part => /^ (ORDER BY|LIMIT|GROUP BY|HAVING|UNION|FOR UPDATE)\b/i.test(part))) {
+            throw new Error('seek requires an ungrouped query without ordering or pagination');
+        }
+        if (values !== undefined) {
+            if (values.length !== fields.length || values.some(value => (typeof value !== 'string' && typeof value !== 'number') ||
+                (typeof value === 'number' && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value)))))) {
+                throw new Error('Invalid cursor values; use strings for large integers');
+            }
+            const columns = fields.map(field => this.field(field));
+            const placeholders = values.map(() => this._placeholder());
+            const left = columns.length === 1 ? columns[0] : `(${columns.join(', ')})`;
+            const right = placeholders.length === 1 ? placeholders[0] : `(${placeholders.join(', ')})`;
+            let condition = `${left} ${d === 'DESC' ? '<' : '>'} ${right}`;
+            if (columns.length > 1) {
+                // --- 显式收紧首列边界，避免已有较宽范围条件让 PG 在索引内遍历到行比较边界 ---
+                condition += ` AND ${columns[0]} ${d === 'DESC' ? '<=' : '>='} ${this._placeholder()}`;
+            }
+            const index = this._sql.findIndex(part => part.startsWith(' WHERE '));
+            if (index === -1) {
+                this._whereDataPosition[0] = this._data.length;
+                this._sql.push(' WHERE ' + condition);
+            }
+            else {
+                this._sql[index] = ` WHERE (${this._sql[index].slice(7)}) AND ${condition}`;
+            }
+            this._data.push(...values);
+            if (columns.length > 1) {
+                this._data.push(values[0]);
+            }
+            this._whereDataPosition[1] = this._data.length;
+        }
+        return this.by(fields, d);
+    }
     /**
      * --- GROUP BY ---
      * @param c 字段字符串或数组
@@ -918,7 +967,13 @@ export class Sql {
                 sql[i] = sql[i].replace(/\$\d+/g, () => `$${counter++}`);
             }
         }
-        return get({
+        for (let i = sql.length - 1; i >= 0; --i) {
+            if ((opt.order === false && sql[i].startsWith(' ORDER BY ')) ||
+                (opt.limit === false && sql[i].startsWith(' LIMIT '))) {
+                sql.splice(i, 1);
+            }
+        }
+        const result = get({
             'service': this._service,
             'ctr': this._ctr,
             'pre': this._pre,
@@ -926,6 +981,10 @@ export class Sql {
             'sql': sql,
             'alias': lCore.clone(this._alias),
         }).hint(this._hint);
+        if (opt.where === undefined) {
+            result._whereDataPosition = [...this._whereDataPosition];
+        }
+        return result;
     }
     // --- 操作 ---
     /**

package/lib/text.d.ts

@@ -1,4 +1,17 @@
 import * as kebab from '#kebab/index.js';
+/**
+ * --- 解析三段正式发行版本 X.Y.Z，不接受前导零、预发行和构建后缀 ---
+ * @param value 待解析的版本
+ * @returns 三段安全整数，无效时返回 null
+ */
+export declare function parseVersion(value: unknown): [number, number, number] | null;
+/**
+ * --- 逐段比较三段正式发行版本 X.Y.Z，不按字符串或浮点数比较 ---
+ * @param version 待比较的版本
+ * @param target 目标版本
+ * @returns 小于返回 -1，等于返回 0，大于返回 1；任一版本无效时返回 null
+ */
+export declare function compareVersion(version: unknown, target: unknown): -1 | 0 | 1 | null;
 /**
  * --- 将文件大小格式化为带单位的字符串 ---
  * @param size 文件大小

package/lib/text.js

@@ -7,6 +7,42 @@ import * as net from 'net';
 import * as kebab from '#kebab/index.js';
 import * as lFs from './fs.js';
 import * as lCore from './core.js';
+/**
+ * --- 解析三段正式发行版本 X.Y.Z，不接受前导零、预发行和构建后缀 ---
+ * @param value 待解析的版本
+ * @returns 三段安全整数，无效时返回 null
+ */
+export function parseVersion(value) {
+    if ((typeof value !== 'string') || (value.length > 64)) {
+        return null;
+    }
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(value);
+    // --- $ 可匹配末尾换行前的位置，必须额外确认匹配完整输入 ---
+    if (match?.[0] !== value) {
+        return null;
+    }
+    const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
+    return parts.every(Number.isSafeInteger) ? parts : null;
+}
+/**
+ * --- 逐段比较三段正式发行版本 X.Y.Z，不按字符串或浮点数比较 ---
+ * @param version 待比较的版本
+ * @param target 目标版本
+ * @returns 小于返回 -1，等于返回 0，大于返回 1；任一版本无效时返回 null
+ */
+export function compareVersion(version, target) {
+    const current = parseVersion(version);
+    const other = parseVersion(target);
+    if (!current || !other) {
+        return null;
+    }
+    for (let index = 0; index < current.length; index++) {
+        if (current[index] !== other[index]) {
+            return current[index] < other[index] ? -1 : 1;
+        }
+    }
+    return 0;
+}
 /**
  * --- 将文件大小格式化为带单位的字符串 ---
  * @param size 文件大小

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.19.1",
+  "version": "9.20.1",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [

package/sys/mod.d.ts

@@ -11,6 +11,13 @@ import * as kebab from '#kebab/index.js';
 export type TOnlyProperties<T> = {
     [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: T[K];
 };
+/** --- 一批游标查询结果，hasMore 表示扫描方向上还有记录 --- */
+export interface ICursorPage<T extends Record<string, unknown> = Record<string, unknown>> {
+    'list': T[];
+    'hasMore': boolean;
+    'next': lSql.TCursorValue[] | null;
+    'previous': lSql.TCursorValue[] | null;
+}
 /** --- 条数列表 --- */
 export declare class Rows<T extends Mod> implements IRows<T> {
     private readonly _items;
@@ -375,6 +382,31 @@ export default class Mod {
      * --- 获取总条数，自动抛弃 LIMIT，仅用于获取数据的情况（select） ---
      */
     total(f?: string): Promise<number>;
+    /**
+     * --- 从 PostgreSQL 执行计划估算查询总行数，移除外层排序和分页，不执行数据扫描 ---
+     * --- 请在应用游标条件前调用；非 PostgreSQL、框架分表联查或查询失败返回 false，绝不回退到 COUNT ---
+     * @returns 近似行数或 false；估算可能偏差很大，不能用于判断有无下一批
+     */
+    totalEstimate(): Promise<number | false>;
+    /**
+     * --- 读取一批游标数据，多取一条判断后续记录，不使用 OFFSET，不修改原查询 ---
+     * --- 排序字段必须全部非空、同向，且组合唯一；SELECT 中须包含对应字段（同名或指定 keys） ---
+     * @param count 本批数量
+     * @param opt 排序、边界和方向；before 为 true 时读取前一批并恢复展示顺序
+     * @param opt.by 排序字段，支持表别名
+     * @param opt.keys SELECT 结果中对应的字段名，默认去掉 by 的表别名
+     * @param opt.order 展示顺序，默认 DESC
+     * @param opt.cursor 边界行的字段值，首批省略
+     * @param opt.before 是否读取边界前一批，须提供 cursor
+     * @returns 列表、首末行游标和扫描方向上的 hasMore，数据库错误返回 false
+     */
+    allCursor<T extends Record<string, unknown> = Record<string, unknown>>(count: number, opt: {
+        'by': string | string[];
+        'keys'?: string[];
+        'order'?: 'DESC' | 'ASC';
+        'cursor'?: lSql.TCursorValue[];
+        'before'?: boolean;
+    }): Promise<ICursorPage<T> | false>;
     /**
      * --- 根据当前条件，筛选出当前条目该有的数据条数 ---
      */

package/sys/mod.js

@@ -1262,6 +1262,89 @@ export default class Mod {
         }
         return count;
     }
+    /**
+     * --- 从 PostgreSQL 执行计划估算查询总行数，移除外层排序和分页，不执行数据扫描 ---
+     * --- 请在应用游标条件前调用；非 PostgreSQL、框架分表联查或查询失败返回 false，绝不回退到 COUNT ---
+     * @returns 近似行数或 false；估算可能偏差很大，不能用于判断有无下一批
+     */
+    async totalEstimate() {
+        if (this._db.getService() !== lDb.ESERVICE.PGSQL || this._index !== null || this._contain) {
+            return false;
+        }
+        const sql = this._sql.copy(undefined, { 'order': false, 'limit': false });
+        const result = await this._db.query('EXPLAIN (FORMAT JSON) ' + sql.getSql(), sql.getData());
+        if (result.rows === null) {
+            lCore.log(this._ctr ?? {}, '[MOD][totalEstimate] Query failed', '-error');
+            return false;
+        }
+        const plan = result.rows[0]?.['QUERY PLAN'];
+        const parsed = typeof plan === 'string' ? lText.parseJson(plan) : plan;
+        if (!Array.isArray(parsed)) {
+            return false;
+        }
+        const root = parsed[0];
+        if (!root || typeof root !== 'object') {
+            return false;
+        }
+        const node = root['Plan'];
+        if (!node || typeof node !== 'object') {
+            return false;
+        }
+        const rows = node['Plan Rows'];
+        return typeof rows === 'number' && Number.isFinite(rows) && rows >= 0 ? Math.round(rows) : false;
+    }
+    /**
+     * --- 读取一批游标数据，多取一条判断后续记录，不使用 OFFSET，不修改原查询 ---
+     * --- 排序字段必须全部非空、同向，且组合唯一；SELECT 中须包含对应字段（同名或指定 keys） ---
+     * @param count 本批数量
+     * @param opt 排序、边界和方向；before 为 true 时读取前一批并恢复展示顺序
+     * @param opt.by 排序字段，支持表别名
+     * @param opt.keys SELECT 结果中对应的字段名，默认去掉 by 的表别名
+     * @param opt.order 展示顺序，默认 DESC
+     * @param opt.cursor 边界行的字段值，首批省略
+     * @param opt.before 是否读取边界前一批，须提供 cursor
+     * @returns 列表、首末行游标和扫描方向上的 hasMore，数据库错误返回 false
+     */
+    async allCursor(count, opt) {
+        if (!Number.isSafeInteger(count) || count < 1 || count >= Number.MAX_SAFE_INTEGER ||
+            this._index !== null || this._contain || (opt.before && !opt.cursor) ||
+            (opt.order !== undefined && !['ASC', 'DESC'].includes(opt.order))) {
+            throw new Error('Invalid cursor page options; framework sharding and contain are unsupported');
+        }
+        const fields = typeof opt.by === 'string' ? [opt.by] : opt.by;
+        const keys = opt.keys ?? fields.map(field => field.split('.').pop());
+        if (keys.length !== fields.length || new Set(keys).size !== keys.length) {
+            throw new Error('Cursor result keys must match ordering fields');
+        }
+        const order = opt.order ?? 'DESC';
+        const direction = opt.before ? (order === 'DESC' ? 'ASC' : 'DESC') : order;
+        const sql = this._sql.copy(undefined, { 'order': false, 'limit': false });
+        sql.seek(fields, opt.cursor, direction).limit(count + 1);
+        const result = await this._db.query(sql.getSql(), sql.getData());
+        if (result.rows === null) {
+            lCore.log(this._ctr ?? {}, '[MOD][allCursor] Query failed', '-error');
+            return false;
+        }
+        const hasMore = result.rows.length > count;
+        const list = result.rows.slice(0, count);
+        if (opt.before) {
+            list.reverse();
+        }
+        const boundary = (row) => keys.map(key => {
+            const value = row[key];
+            if ((typeof value !== 'string' && typeof value !== 'number') ||
+                (typeof value === 'number' && (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))))) {
+                throw new Error('Cursor columns must be non-null strings or safe numbers');
+            }
+            return value;
+        });
+        return {
+            'list': list,
+            'hasMore': hasMore,
+            'next': list.length ? boundary(list[list.length - 1]) : null,
+            'previous': list.length ? boundary(list[0]) : null,
+        };
+    }
     /**
      * --- 根据当前条件，筛选出当前条目该有的数据条数 ---
      */