@byted-apaas/server-sdk-node 0.0.2-beta.1

package/context/db/db.d.ts

@@ -0,0 +1,73 @@
+import { currentObjApiName } from '../../data';
+import { _IKAllEndpoint, _IKSyncEndpoint, _IKQuery } from './impl/IObject';
+import { ITransactionGetter } from './impl/transaction';
+import { IOql } from './impl/oql/ioql';
+/**
+ * - IDBGetter 是声明 DB interface 的顶级入口，在使用时应该避免直接使用 IDB 和 IDBWithCurrentObject
+ * 应该直接使用 IDBGetter。
+ * - 目前 IDBGetter 支持的是 currentObject 方法的动态声明，使用泛型实现，期望传入的 T 是 Context 结构。
+ * - 如果 Context 有 objectApiName 属性，则拥有 .db.currentObject 和 .db.transaction.currentObject
+ */
+export declare type IDBGetter<T, mt> = T extends {
+    'objectApiName': string;
+} ? IDB<T, mt> & IDBWithCurrentObject<{}, mt> : IDB<{}, mt>;
+/**
+ * IDB 经由 IDBGetter 返回，是 DB 的基础接口结构
+ */
+export interface IDB<T, mt> {
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).find()
+     * ```
+     */
+    object<T extends keyof mt>(objectApiName: T): _IKAllEndpoint<mt[T]> & _IKQuery<mt[T]>;
+    /**
+     * 创建一个新的空事务
+     * @example
+     * ```
+     * let tx = context.db.newTransaction();
+     * let user = tx.object("_user").registerCreate({
+     *     _name: new kunlun.type.Multilingual({ zh: "用户1", en: "user1" }),
+     * });
+     * let contract = tx.object("contract").registerCreate({
+     *     _name: new kunlun.type.Multilingual({ zh: "用户1的合同", en: "user1's contract" }),
+     *     user: {id: user._id}
+     * });
+     * await tx.commit();
+     * ```
+     */
+    newTransaction(): ITransactionGetter<T, mt>;
+    /**
+     * OQL 操作
+     * @param oql OQL 语句
+     * @example
+     * ```
+     * let users = await context.db.oql("select _email from _user").execute();
+     * ```
+     */
+    oql(oql: string): IOql;
+}
+/**
+ * IDBWithCurrentObject 经由 IDBGetter 返回，是 DB 的动态增加的接口结构
+ */
+export interface IDBWithCurrentObject<T, mt> {
+    /**
+     * 无需入参，操作当前对象的记录数据
+     */
+    currentObject(): _IKAllEndpoint<mt[currentObjApiName]> & _IKQuery<mt[currentObjApiName]>;
+}
+/**
+ * IDBSync 仅包含同步调用接口，当前应用场景为 OpenSDK
+ */
+export interface IDBSync<mt = Record<string, never>> {
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     */
+    object(objectApiName: string): _IKSyncEndpoint<mt> & _IKQuery<mt>;
+}

package/context/db/db.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=db.js.map

package/context/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","sourceRoot":"","sources":["db.ts"],"names":[],"mappings":""}

package/context/db/db.ts

@@ -0,0 +1,77 @@
+import { currentObjApiName } from '../../data'
+import { _IKAllEndpoint, _IKSyncEndpoint, _IKQuery } from './impl/IObject';
+import { ITransactionGetter } from './impl/transaction';
+import { IOql } from './impl/oql/ioql';
+
+/**
+ * - IDBGetter 是声明 DB interface 的顶级入口，在使用时应该避免直接使用 IDB 和 IDBWithCurrentObject
+ * 应该直接使用 IDBGetter。
+ * - 目前 IDBGetter 支持的是 currentObject 方法的动态声明，使用泛型实现，期望传入的 T 是 Context 结构。
+ * - 如果 Context 有 objectApiName 属性，则拥有 .db.currentObject 和 .db.transaction.currentObject
+ */
+export type IDBGetter<T, mt> = T extends { 'objectApiName': string } ? IDB<T, mt> & IDBWithCurrentObject<{}, mt> : IDB<{}, mt>;
+
+/**
+ * IDB 经由 IDBGetter 返回，是 DB 的基础接口结构
+ */
+export interface IDB<T, mt> {
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).find()
+     * ```
+     */
+    object<T extends keyof mt>(objectApiName: T): _IKAllEndpoint<mt[T]> & _IKQuery<mt[T]>;
+
+    /**
+     * 创建一个新的空事务
+     * @example
+     * ```
+     * let tx = context.db.newTransaction();
+     * let user = tx.object("_user").registerCreate({
+     *     _name: new kunlun.type.Multilingual({ zh: "用户1", en: "user1" }),
+     * });
+     * let contract = tx.object("contract").registerCreate({
+     *     _name: new kunlun.type.Multilingual({ zh: "用户1的合同", en: "user1's contract" }),
+     *     user: {id: user._id}
+     * });
+     * await tx.commit();
+     * ```
+     */
+    newTransaction(): ITransactionGetter<T, mt>;
+    /**
+     * OQL 操作
+     * @param oql OQL 语句
+     * @example
+     * ```
+     * let users = await context.db.oql("select _email from _user").execute();
+     * ```
+     */
+    oql(oql: string): IOql;
+}
+
+/**
+ * IDBWithCurrentObject 经由 IDBGetter 返回，是 DB 的动态增加的接口结构
+ */
+export interface IDBWithCurrentObject<T, mt> {
+    /**
+     * 无需入参，操作当前对象的记录数据
+     */
+    // @ts-ignore
+    currentObject(): _IKAllEndpoint<mt[currentObjApiName]> & _IKQuery<mt[currentObjApiName]>;
+}
+
+/**
+ * IDBSync 仅包含同步调用接口，当前应用场景为 OpenSDK
+ */
+export interface IDBSync<mt = Record<string, never>> {
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     */
+    object(objectApiName: string): _IKSyncEndpoint<mt> & _IKQuery<mt>;
+}

package/context/db/impl/IObject.d.ts

@@ -0,0 +1,251 @@
+import { _Cond, _Record, _WhereCond } from '../../../types/types';
+export interface _IKAllEndpoint<T> extends _IKSyncEndpoint<T>, _IKAsyncEndpoint<T> {
+}
+export interface _IKSyncEndpoint<T> {
+    /**
+     * 创建记录
+     * @param recordMap 用于创建的一条记录
+     * @paramExample {_name: "John", age: 19, gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_department").create({
+     *     _name: new kunlun.type.Multilingual({ zh: "部门" }),
+     *     _manager: { _id: 1660000000 },
+     *     _status: "_active"
+     * })
+     * ```
+     */
+    create(recordMap: _Cond<T>): Promise<{
+        _id: number;
+    }>;
+    /**
+     * 删除记录
+     * @param recordID 用于删除的一条记录的 ID
+     * @example
+     * ```
+     * context.db.object("_user").delete(123456789123)
+     * ```
+     */
+    delete(recordID: number): Promise<void>;
+    /**
+     * 删除记录
+     * @param record 用于删除的一条完整记录
+     * @example
+     * ```
+     * context.db.object("_user").delete(context.targetRecord.original)
+     * ```
+     */
+    delete(record: _Cond<T>): Promise<void>;
+    /**
+     * 指定 _id 后，更新对应记录
+     * @param _id 主键
+     * @param recordMap 用于更新的一条记录
+     * @paramExample {_name: "John", age: 19, gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_user").update(1660000000, {
+     *     gender: "male"
+     * })
+     * ```
+     */
+    update(_id: number, recordMap: _Cond<T>): Promise<void>;
+    /**
+     * 指定 _id 后，更新对应记录
+     * @param recordMap 用于更新的一条记录，需对 _id 赋值
+     * @paramExample {_id: 1660000000, _name: "John", age: 19, gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_user").update({
+     *     _id: 1660000000,
+     *     gender: "male"
+     * })
+     * ```
+     */
+    update(recordMap: _Cond<T>): Promise<void>;
+    /**
+     * 批量创建记录
+     * @param recordMapList 多条用于创建的记录数据组成的数组
+     * @paramExample [{_name: "John", age: 19, gender: "male"}, {_name: "Alis", age: 16, gender: "female"}]
+     */
+    batchCreate(recordMapList: _Cond<T>[]): Promise<number[]>;
+    /**
+     * 批量删除记录
+     * @param recordIdList 多个用于删除的记录 ID 组成的数组
+     * @paramExample [1001, 1002, 1003]
+     */
+    batchDelete(recordIdList: number[]): Promise<void>;
+    /**
+     * 批量删除记录
+     * @param recordList 多条用于删除的记录数据组成的数组，记录数据需对 _id 赋值
+     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
+     */
+    batchDelete(recordList: _Cond<T>[]): Promise<void>;
+    /**
+     * 根据 _id 批量更新记录
+     * @param recordMapList 多条用于更新的记录数据组成的数组，记录数据需对 _id 赋值
+     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
+     */
+    batchUpdate(recordMapList: _Cond<T>[]): Promise<void>;
+}
+export interface _IKAsyncEndpoint<T> {
+    /**
+     * 批量创建记录（为异步任务）
+     * @param recordMapList 用于创建的多条记录
+     * @paramExample [{_name: "John", age: 19, gender: "male"}, {_name: "Alis", age: 16, gender: "female"}]
+     */
+    batchCreateAsync(recordMapList: _Cond<T>[]): Promise<{
+        taskID: number;
+    }>;
+    /**
+     * 批量删除记录（为异步任务）
+     * @param recordIDList 用于删除的多条记录的 ID 列表
+     */
+    batchDeleteAsync(recordIDList: number[]): Promise<{
+        taskID: number;
+    }>;
+    /**
+     * 批量删除记录（为异步任务）
+     * @param recordList 用于删除的多条完整记录的列表
+     */
+    batchDeleteAsync(recordList: _Cond<T>[]): Promise<{
+        taskID: number;
+    }>;
+    /**
+     * 根据 _id 批量更新记录（为异步任务）
+     * @param recordMapList 用于更新的多条记录，需对 _id 赋值
+     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
+     */
+    batchUpdateAsync(recordMapList: _Cond<T>[]): Promise<{
+        taskID: number;
+    }>;
+}
+export interface _IKQuery<T> {
+    /**
+     * 无需入参，返回全部符合条件的记录
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).findAll()
+     * ```
+     */
+    findAll(): Promise<_Record<T>[]>;
+    /**
+     * 无需入参，返回符合条件的记录，单次返回 200 条
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).find()
+     * ```
+     */
+    find(): Promise<_Record<T>[]>;
+    /**
+     * 无需入参，返回排在第一位的记录
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).findOne()
+     * ```
+     */
+    findOne(): Promise<_Record<T>>;
+    /**
+     * 根据指定字段升序排序（a -> z, 0 -> 9）
+     * @param fieldApiNames 排序依据的字段数组，按先后顺序确定优先级
+     * @example
+     * ```
+     * context.db.object("_user").orderBy(["_email", "_phoneNumber"]).find()
+     * ```
+     */
+    orderBy<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 根据指定字段升序排序（a -> z, 0 -> 9）
+     * @param fieldApiNames 排序依据的字段，按先后顺序确定优先级，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").orderBy("_email", "_phoneNumber").find()
+     * ```
+     */
+    orderBy<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 根据指定字段降序排序（z -> a, 9 -> 0）
+     * @param fieldApiNames 排序依据的字段数组，按先后顺序确定优先级
+     * @example
+     * ```
+     * context.db.object("_user").orderByDesc("_email", "_phoneNumber").find()
+     * ```
+     */
+    orderByDesc<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 根据指定字段降序排序（z -> a, 9 -> 0）
+     * @param fieldApiNames 排序依据的字段，按先后顺序确定优先级，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").orderByDesc("_email", "_phoneNumber").find()
+     * ```
+     */
+    orderByDesc<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 指定需返回的字段
+     * @param fieldApiNames 需返回的字段数组
+     * @example
+     * ```
+     * context.db.object("_user").select(["_name", "_email"]).find()
+     * ```
+     */
+    select<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 指定需返回的字段
+     * @param fieldApiNames 需返回的字段，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").select("_name", "_email").find()
+     * ```
+     */
+    select<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 设置查询条件
+     * @param conditionMap 对字段赋值以指定查询筛选条件
+     * @paramExample {gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).find()
+     * ```
+     */
+    where(conditionMap: _WhereCond<T>): _IKQuery<T>;
+    /**
+     * 设置查询条件
+     */
+    where(): _IKQuery<T>;
+    /**
+     * 指定分页查询的数量
+     * @param limit 分页查询的数量
+     * @paramExample 10
+     * @example
+     * ```
+     * context.db.object("_user").limit(10)
+     * ```
+     */
+    limit(limit: number): _IKQuery<T>;
+    /**
+     * 指定分页查询的偏移量
+     * @param offset 分页查询的偏移量
+     * @paramExample 0
+     * @example
+     * ```
+     * context.db.object("_user").offset(0)
+     * ```
+     */
+    offset(offset: number): _IKQuery<T>;
+    /**
+     * 指定条件的行数
+     * @example
+     * ```
+     * context.db.object("_user").count()
+     * ```
+     */
+    count(): Promise<number>;
+}

package/context/db/impl/IObject.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;
+//# sourceMappingURL=IObject.js.map

package/context/db/impl/IObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IObject.js","sourceRoot":"","sources":["IObject.ts"],"names":[],"mappings":";;AAEsF,CAAC"}

package/context/db/impl/IObject.ts

@@ -0,0 +1,244 @@
+import { _Cond, _Record, _WhereCond } from '../../../types/types'
+
+export interface _IKAllEndpoint<T> extends _IKSyncEndpoint<T>, _IKAsyncEndpoint<T> { };
+
+export interface _IKSyncEndpoint<T> {
+    /**
+     * 创建记录
+     * @param recordMap 用于创建的一条记录
+     * @paramExample {_name: "John", age: 19, gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_department").create({
+     *     _name: new kunlun.type.Multilingual({ zh: "部门" }),
+     *     _manager: { _id: 1660000000 },
+     *     _status: "_active"
+     * })
+     * ```
+     */
+    create(recordMap: _Cond<T>): Promise<{ _id: number }>;
+    /**
+     * 删除记录
+     * @param recordID 用于删除的一条记录的 ID
+     * @example
+     * ```
+     * context.db.object("_user").delete(123456789123)
+     * ```
+     */
+    delete(recordID: number): Promise<void>;
+    /**
+     * 删除记录
+     * @param record 用于删除的一条完整记录
+     * @example
+     * ```
+     * context.db.object("_user").delete(context.targetRecord.original)
+     * ```
+     */
+    delete(record: _Cond<T>): Promise<void>;
+    /**
+     * 指定 _id 后，更新对应记录
+     * @param _id 主键
+     * @param recordMap 用于更新的一条记录
+     * @paramExample {_name: "John", age: 19, gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_user").update(1660000000, {
+     *     gender: "male"
+     * })
+     * ```
+     */
+    update(_id: number, recordMap: _Cond<T>): Promise<void>;
+    /**
+     * 指定 _id 后，更新对应记录
+     * @param recordMap 用于更新的一条记录，需对 _id 赋值
+     * @paramExample {_id: 1660000000, _name: "John", age: 19, gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_user").update({
+     *     _id: 1660000000,
+     *     gender: "male"
+     * })
+     * ```
+     */
+    update(recordMap: _Cond<T>): Promise<void>;
+    /**
+     * 批量创建记录
+     * @param recordMapList 多条用于创建的记录数据组成的数组
+     * @paramExample [{_name: "John", age: 19, gender: "male"}, {_name: "Alis", age: 16, gender: "female"}]
+     */
+    batchCreate(recordMapList: _Cond<T>[]): Promise<number[]>;
+    /**
+     * 批量删除记录
+     * @param recordIdList 多个用于删除的记录 ID 组成的数组
+     * @paramExample [1001, 1002, 1003]
+     */
+    batchDelete(recordIdList: number[]): Promise<void>;
+    /**
+     * 批量删除记录
+     * @param recordList 多条用于删除的记录数据组成的数组，记录数据需对 _id 赋值
+     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
+     */
+    batchDelete(recordList: _Cond<T>[]): Promise<void>;
+    /**
+     * 根据 _id 批量更新记录
+     * @param recordMapList 多条用于更新的记录数据组成的数组，记录数据需对 _id 赋值
+     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
+     */
+    batchUpdate(recordMapList: _Cond<T>[]): Promise<void>;
+}
+
+export interface _IKAsyncEndpoint<T> {
+    /**
+     * 批量创建记录（为异步任务）
+     * @param recordMapList 用于创建的多条记录
+     * @paramExample [{_name: "John", age: 19, gender: "male"}, {_name: "Alis", age: 16, gender: "female"}]
+     */
+    batchCreateAsync(recordMapList: _Cond<T>[]): Promise<{ taskID: number }>;
+    /**
+     * 批量删除记录（为异步任务）
+     * @param recordIDList 用于删除的多条记录的 ID 列表
+     */
+    batchDeleteAsync(recordIDList: number[]): Promise<{ taskID: number }>;
+    /**
+     * 批量删除记录（为异步任务）
+     * @param recordList 用于删除的多条完整记录的列表
+     */
+    batchDeleteAsync(recordList: _Cond<T>[]): Promise<{ taskID: number }>;
+    /**
+     * 根据 _id 批量更新记录（为异步任务）
+     * @param recordMapList 用于更新的多条记录，需对 _id 赋值
+     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
+     */
+    batchUpdateAsync(recordMapList: _Cond<T>[]): Promise<{ taskID: number }>;
+}
+
+export interface _IKQuery<T> {
+    /**
+     * 无需入参，返回全部符合条件的记录
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).findAll()
+     * ```
+     */
+    findAll(): Promise<_Record<T>[]>;
+    /**
+     * 无需入参，返回符合条件的记录，单次返回 200 条
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).find()
+     * ```
+     */
+    find(): Promise<_Record<T>[]>;
+    /**
+     * 无需入参，返回排在第一位的记录
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).findOne()
+     * ```
+     */
+    findOne(): Promise<_Record<T>>;
+    /**
+     * 根据指定字段升序排序（a -> z, 0 -> 9）
+     * @param fieldApiNames 排序依据的字段数组，按先后顺序确定优先级
+     * @example
+     * ```
+     * context.db.object("_user").orderBy(["_email", "_phoneNumber"]).find()
+     * ```
+     */
+    orderBy<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 根据指定字段升序排序（a -> z, 0 -> 9）
+     * @param fieldApiNames 排序依据的字段，按先后顺序确定优先级，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").orderBy("_email", "_phoneNumber").find()
+     * ```
+     */
+    orderBy<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 根据指定字段降序排序（z -> a, 9 -> 0）
+     * @param fieldApiNames 排序依据的字段数组，按先后顺序确定优先级
+     * @example
+     * ```
+     * context.db.object("_user").orderByDesc("_email", "_phoneNumber").find()
+     * ```
+     */
+    orderByDesc<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 根据指定字段降序排序（z -> a, 9 -> 0）
+     * @param fieldApiNames 排序依据的字段，按先后顺序确定优先级，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").orderByDesc("_email", "_phoneNumber").find()
+     * ```
+     */
+    orderByDesc<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 指定需返回的字段
+     * @param fieldApiNames 需返回的字段数组
+     * @example
+     * ```
+     * context.db.object("_user").select(["_name", "_email"]).find()
+     * ```
+     */
+    select<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 指定需返回的字段
+     * @param fieldApiNames 需返回的字段，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").select("_name", "_email").find()
+     * ```
+     */
+    select<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
+    /**
+     * 设置查询条件
+     * @param conditionMap 对字段赋值以指定查询筛选条件
+     * @paramExample {gender: "male"}
+     * @example
+     * ```
+     * context.db.object("_user").where({
+     *     gender: "male"
+     * }).find()
+     * ```
+     */
+    where(conditionMap: _WhereCond<T>): _IKQuery<T>;
+    /**
+     * 设置查询条件
+     */
+    where(): _IKQuery<T>;
+    /**
+     * 指定分页查询的数量
+     * @param limit 分页查询的数量
+     * @paramExample 10
+     * @example
+     * ```
+     * context.db.object("_user").limit(10)
+     * ```
+     */
+    limit(limit: number): _IKQuery<T>;
+    /**
+     * 指定分页查询的偏移量
+     * @param offset 分页查询的偏移量
+     * @paramExample 0
+     * @example
+     * ```
+     * context.db.object("_user").offset(0)
+     * ```
+     */
+    offset(offset: number): _IKQuery<T>;
+    /**
+     * 指定条件的行数
+     * @example
+     * ```
+     * context.db.object("_user").count()
+     * ```
+     */
+    count(): Promise<number>;
+}