@cloudcome/utils-uni 1.13.0 → 1.14.0

package/dist/database/_command.class.d.ts

@@ -0,0 +1,15 @@
+export declare class DbBaseCommand {
+    command: string;
+    parameter: unknown;
+    constructor(command: string, parameter: unknown);
+    getValue(db: UniCloud.Database): unknown;
+    getExpression(fieldName: string): {
+        [x: string]: unknown[];
+    };
+}
+export declare class DbQueryCommand extends DbBaseCommand {
+    isQueryCommand: boolean;
+}
+export declare class DbMutateCommand extends DbBaseCommand {
+    isMutateCommand: boolean;
+}

package/dist/database/{db.class.d.ts → _db.class.d.ts}

@@ -1,7 +1,7 @@
 import { AnyObject, Exact, HasProperty, IsEmptyObject, IsOnlyProperty, MergeIntersection } from '@cloudcome/utils-core/types';
-import { DatabaseMutateCommand, DatabaseQueryCommand } from './types';
+import { DbMutateCommand, DbQueryCommand } from './_command.class';
 export type DbWhere<T> = {
-    [K in keyof T]?: T[K] | DatabaseQueryCommand;
+    [K in keyof T]?: T[K] | DbQueryCommand;
 };
 export type DbSelect<T> = {
     [K in keyof T]?: K extends '_id' ? boolean : true;
@@ -9,21 +9,21 @@ export type DbSelect<T> = {
 export type DbFieldsDefault<T> = {
     [K in keyof T]: true;
 };
-type _OnlyFieldId<T, V> = IsOnlyProperty<T, '_id'> extends true ? '_id' extends keyof T ? T['_id'] extends V ? true : false : false : false;
-type _DbFields<T, S extends DbSelect<T>> = IsEmptyObject<S> extends true ? DbFieldsDefault<T> : _OnlyFieldId<S, false> extends true ? Omit<DbFieldsDefault<T>, '_id'> : _OnlyFieldId<S, true> extends true ? {
+type _OnlyFieldId<D, V> = IsOnlyProperty<D, '_id'> extends true ? '_id' extends keyof D ? D['_id'] extends V ? true : false : false : false;
+type _DbFields<D, S extends DbSelect<D>> = IsEmptyObject<S> extends true ? DbFieldsDefault<D> : _OnlyFieldId<S, false> extends true ? Omit<DbFieldsDefault<D>, '_id'> : _OnlyFieldId<S, true> extends true ? {
     _id: true;
 } : HasProperty<S, '_id'> extends true ? S : // 没有的话补上 {_id, ...}
 S & {
     _id: true;
 };
-type _DbQuery<T, S extends Record<keyof T, boolean>> = {
-    [K in keyof T as S[K] extends true ? K : never]: T[K];
+type _DbQuery<D1, S1 extends DbSelect<D1>> = {
+    [K in keyof D1 as S1[K] extends true ? K : never]: D1[K];
 };
-export type DbQuery<T, S extends DbSelect<T>, R> = _DbQuery<T, _DbFields<T, S>> & R;
-export type DbForeign<T, S extends DbSelect<T>, R, J extends DbJoinType, A> = Record<A & string, J extends '1:1' ? DbQuery<T, S, R> : DbQuery<T, S, R>[]>;
+export type DbQuery<D1, S1 extends DbSelect<D1>, D2> = _DbQuery<D1, _DbFields<D1, S1>> & D2;
+export type DbForeign<D1, S1 extends DbSelect<D1>, D2, JT extends DbJoinType, AS extends string> = Record<AS, JT extends '1:1' ? DbQuery<D1, S1, D2> : DbQuery<D1, S1, D2>[]>;
 export type DbCreate<T> = Partial<T>;
 export type DbUpdate<T> = {
-    [K in keyof T]?: T[K] | DatabaseMutateCommand;
+    [K in keyof T]?: T[K] | DbMutateCommand;
 };
 export type DbOrder<T> = Record<keyof T, 'asc' | 'desc'>;
 export type DbOptions = {
@@ -47,52 +47,50 @@ export type DbOptions = {
  * - 'n:1': 多对一关联，返回值 n 个
  */
 export type DbJoinType = '1:1' | '1:n' | 'n:1';
-export type DbLookupOptions<J extends DbJoinType, L, F, A> = {
+export type DbLookupOptions<JT extends DbJoinType, D1, FD1, AS, US extends boolean | undefined | void = undefined> = {
     /**
      * 关联类型
      */
-    type: J;
+    type: JT;
     /**
      * 主表字段
      */
-    localField: keyof L & string;
+    localField: keyof D1 & string;
     /**
      * 关联表字段
      */
-    foreignField: keyof F & string;
+    foreignField: keyof FD1 & string;
     /**
      * 关联数据在结果中的字段名
      */
-    as: A;
+    as: AS;
+    /**
+     * 是否取消筛选关联数据
+     */
+    unselect?: US;
 };
-export type DbLookup = {
+export type DbLookup = DbLookupOptions<any, unknown, unknown, string, boolean> & {
     /**
      * 关联表
      */
     table: Db<unknown>;
+};
+/**
+ * 数据库类
+ * @template D1 - 主表数据
+ * @template S1 - 主表筛选
+ * @template D2 - 副表数据
+ * @template W2 - 副表查询
+ */
+export declare class Db<D1, S1 extends DbSelect<D1> = {}, D2 extends AnyObject = {}, W2 extends AnyObject = {}> {
+    private _host;
     /**
-     * 关联类型
-     */
-    type: DbJoinType;
-    /**
-     * 主表字段
-     */
-    localField: string;
-    /**
-     * 关联表字段
-     */
-    foreignField: string;
-    /**
-     * 关联表名称
-     */
-    from: string;
-    /**
-     * 关联数据在结果中的字段名
+     * 是否为事务环境
+     * - 查询条件只能是 id
+     * - 不能聚合操作
      */
-    as: string;
-};
-export declare class Db<T, S extends DbSelect<T> = {}, R extends AnyObject = {}> {
-    #private;
+    private _isTransaction;
+    private _options;
     /**
      * 构造函数，初始化数据库集合引用
      * @param collection 数据表名称
@@ -105,57 +103,74 @@ export declare class Db<T, S extends DbSelect<T> = {}, R extends AnyObject = {}>
      * @returns 聚合操作实例
      */
     aggregate(): UniCloud.AggregateReference;
+    private _hasWhere;
+    private _hasWhereId;
+    private _where;
+    private _doWhere;
     /**
      * 设置查询条件
      * @param where 查询条件对象
      * @returns 当前Db实例，支持链式调用
      */
-    where(where: DbWhere<T>): this;
+    where(where: DbWhere<D1> & W2): this;
     /**
      * 根据ID设置查询条件
      * @param id 记录ID
      * @returns 当前Db实例，支持链式调用
      */
     whereId(id: string | number): this;
+    private _hasSelect;
+    private _select;
     /**
      * 指定要返回的字段
      * @param fields 要返回的字段对象，true表示返回，false表示不返回
      * @returns 当前Db实例，支持链式调用
      */
-    select<U extends DbSelect<T>>(fields: Exact<U, DbSelect<T>>): Db<T, S & U, R>;
+    select<S extends DbSelect<D1>>(fields: Exact<S, DbSelect<D1>>): this;
+    private _hasOrder;
+    private _order;
     /**
      * 设置排序规则
      * @param order 排序规则对象，key为字段名，value为"asc"或"desc"
      * @returns 当前Db实例，支持链式调用
      */
-    order(order: DbOrder<T>): this;
+    order(order: DbOrder<D1>): this;
+    private _hasSkip;
+    private _skip;
     /**
      * 跳过指定数量的记录
      * @param skip 要跳过的记录数
      * @returns 当前Db实例，支持链式调用
      */
     skip(skip: number): this;
+    private _hasLimit;
+    private _limit;
     /**
      * 限制返回的记录数量
      * @param limit 最大返回记录数
      * @returns 当前Db实例，支持链式调用
      */
     limit(limit: number): this;
+    private _hasLookup;
     get hasLookup(): boolean;
-    lookup<FT, FS extends DbSelect<FT>, FR extends AnyObject, J extends DbJoinType, A extends string>(table: Db<FT, FS, FR>, lookup: DbLookupOptions<J, T, FT, A>): Db<T, S, MergeIntersection<R & DbForeign<FT, FS, FR, J, A>>>;
+    private _lookups;
+    lookup<FD1, FS1 extends DbSelect<FD1>, FD2 extends AnyObject, FW2 extends AnyObject, JT extends DbJoinType, AS extends string, US extends boolean | undefined | void = undefined>(table: Db<FD1, FS1, FD2, FW2>, lookup: DbLookupOptions<JT, D1, FD1, AS, US>): Db<D1, S1, US extends true ? D2 : MergeIntersection<D2 & DbForeign<FD1, FS1, FD2, JT, AS>>, MergeIntersection<W2 & Partial<Record<AS, DbQueryCommand>>>>;
+    private _aggregated;
+    private _endAggregate;
+    private _endHost;
     /**
      * 执行查询操作
      * @returns 查询结果
      */
-    query(): Promise<DbQuery<T, S, R>[]>;
+    query(): Promise<DbQuery<D1, S1, D2>[]>;
     /**
      * 只查询一条，自动添加 limit(1) 条件
-     * @param ignoreMiss 是否忽略没有匹配到记录
+     * @param allowMiss 是否允许没有匹配到记录，如果为 true，则可能返回 undefined
      * @returns 查询结果
      */
-    queryOne(): Promise<DbQuery<T, S, R>>;
-    queryOne(ignoreMiss: false): Promise<DbQuery<T, S, R>>;
-    queryOne(ignoreMiss: true): Promise<DbQuery<T, S, R> | undefined>;
+    queryOne(): Promise<DbQuery<D1, S1, D2>>;
+    queryOne(allowMiss: false): Promise<DbQuery<D1, S1, D2>>;
+    queryOne(allowMiss: true): Promise<DbQuery<D1, S1, D2> | undefined>;
     /**
      * 获取匹配记录的数量
      * @returns 记录总数
@@ -166,7 +181,7 @@ export declare class Db<T, S extends DbSelect<T> = {}, R extends AnyObject = {}>
      * @param data 要创建的数据
      * @returns 创建结果
      */
-    create(data: DbCreate<T>): Promise<string>;
+    create(data: DbCreate<D1>): Promise<string>;
     /**
      * 更新记录
      * @param data 要更新的数据

package/dist/database/command.d.ts

@@ -1,13 +1,122 @@
-import { DatabaseCommand } from './types';
+import { DbMutateCommand, DbQueryCommand } from './_command.class';
 /**
- * 数据库操作符命令
+ * 数据库查询命令对象，提供各种查询操作符
  */
-export declare const dbCmd: DatabaseCommand;
+export declare const dbQuery: {
+    /**
+     * 等于操作符
+     * @param value 比较值
+     * @returns DbQueryCommand 查询命令对象
+     */
+    eq: (value: unknown) => DbQueryCommand;
+    /**
+     * 不等于操作符
+     * @param value 比较值
+     * @returns DbQueryCommand 查询命令对象
+     */
+    neq: (value: unknown) => DbQueryCommand;
+    /**
+     * 大于操作符
+     * @param value 比较值
+     * @returns DbQueryCommand 查询命令对象
+     */
+    gt: (value: unknown) => DbQueryCommand;
+    /**
+     * 大于等于操作符
+     * @param value 比较值
+     * @returns DbQueryCommand 查询命令对象
+     */
+    gte: (value: unknown) => DbQueryCommand;
+    /**
+     * 小于操作符
+     * @param value 比较值
+     * @returns DbQueryCommand 查询命令对象
+     */
+    lt: (value: unknown) => DbQueryCommand;
+    /**
+     * 小于等于操作符
+     * @param value 比较值
+     * @returns DbQueryCommand 查询命令对象
+     */
+    lte: (value: unknown) => DbQueryCommand;
+    /**
+     * 包含在数组中操作符
+     * @param value 值数组
+     * @returns DbQueryCommand 查询命令对象
+     */
+    in: (value: unknown[]) => DbQueryCommand;
+    /**
+     * 不包含在数组中操作符
+     * @param value 值数组
+     * @returns DbQueryCommand 查询命令对象
+     */
+    nin: (value: unknown[]) => DbQueryCommand;
+    /**
+     * 逻辑与操作符
+     * @param conditions 查询条件参数
+     * @returns DbQueryCommand 查询命令对象
+     */
+    and: (conditions: unknown[]) => DbQueryCommand;
+    /**
+     * 逻辑或操作符
+     * @param conditions 查询条件参数
+     * @returns DbQueryCommand 查询命令对象
+     */
+    or: (conditions: unknown[]) => DbQueryCommand;
+    /**
+     * 数组长度匹配操作符
+     * @param size 数组长度
+     * @returns DbQueryCommand 查询命令对象
+     */
+    size: (size: number) => DbQueryCommand;
+};
 /**
- * 数据库聚合操作符命令
+ * 数据库变更命令对象，提供各种数据更新操作符
  */
-export declare const dbAgg: UniCloud.AggregateCommand & {
-    pipeline: () => UniCloud.AggregateReference & {
-        done: () => unknown;
-    };
+export declare const dbMutate: {
+    /**
+     * 数值增加操作符
+     * @param value 增加的数值
+     * @returns DbMutateCommand 变更命令对象
+     */
+    inc: (value: number) => DbMutateCommand;
+    /**
+     * 数值乘法操作符
+     * @param value 乘数
+     * @returns DbMutateCommand 变更命令对象
+     */
+    mul: (value: number) => DbMutateCommand;
+    /**
+     * 设置字段值操作符
+     * @param value 设置的值
+     * @returns DbMutateCommand 变更命令对象
+     */
+    set: (value: unknown) => DbMutateCommand;
+    /**
+     * 向数组末尾添加元素操作符
+     * @param value 添加的值
+     * @returns DbMutateCommand 变更命令对象
+     */
+    push: (value: unknown) => DbMutateCommand;
+    /**
+     * 向数组开头添加元素操作符
+     * @param value 添加的值
+     * @returns DbMutateCommand 变更命令对象
+     */
+    unshift: (value: unknown) => DbMutateCommand;
+    /**
+     * 从数组末尾移除元素操作符
+     * @returns DbMutateCommand 变更命令对象
+     */
+    pop: () => DbMutateCommand;
+    /**
+     * 从数组开头移除元素操作符
+     * @returns DbMutateCommand 变更命令对象
+     */
+    shift: () => DbMutateCommand;
+    /**
+     * 移除字段操作符
+     * @returns DbMutateCommand 变更命令对象
+     */
+    remove: () => DbMutateCommand;
 };

package/dist/database/proxy.d.ts

@@ -1,20 +1,17 @@
-import { AnyObject } from '@cloudcome/utils-core/types';
-import { Db, DbSelect } from './db.class';
+import { Db, DbSelect } from './_db.class';
 /**
  * DbProxy 类型定义，用于创建数据库代理对象
- * @template T - 数据库表的类型
- * @template S - 数据库选择器类型，默认为空对象
- * @template R - 数据库返回结果类型，默认为空对象
+ * @template D1 - 主表数据
+ * @template S1 - 主表筛选
  */
-export type DbProxy<T, S extends DbSelect<T> = {}, R extends AnyObject = {}> = Db<T, S, R> & {
+export type DbProxy<D1, S1 extends DbSelect<D1> = {}> = Db<D1, S1> & {
     _isProxy: true;
 };
 /**
  * 创建一个数据库代理对象，用于延迟实例化数据库操作类
- * @template T - 数据库表的类型
- * @template S - 数据库选择器类型，默认为空对象
- * @template R - 数据库返回结果类型，默认为空对象
+ * @template D1 - 主表数据
+ * @template S1 - 主表筛选
  * @param name - 数据库表名
  * @returns 返回一个代理对象，该对象会将属性访问转发到实际的数据库操作实例
  */
-export declare function dbProxy<T, S extends DbSelect<T> = {}, R extends AnyObject = {}>(name: string): DbProxy<T>;
+export declare function dbProxy<D1, S1 extends DbSelect<D1> = {}>(name: string): DbProxy<D1, S1>;

package/dist/database/transaction.d.ts

@@ -1,11 +1,10 @@
-import { AnyObject } from '@cloudcome/utils-core/types';
-import { Db, DbSelect } from './db.class';
+import { Db } from './_db.class';
 import { DbProxy } from './proxy';
-type _WithTransaction = <T, S extends DbSelect<T>, R extends AnyObject>(table: DbProxy<T, S, R>) => Db<T, S, R>;
+type _WithTransaction = <D1>(table: DbProxy<D1>) => Db<D1>;
 /**
  * 在数据库事务中执行操作
  *
- * @template T - 事务操作返回值类型
+ * @template K - 事务操作返回值类型
  * @param transacting - 事务执行函数，接收事务数据库实例作为参数
  * @param _mockDatabase - 用于测试的模拟数据库对象
  * @param _mockDbInstance - 用于测试的模拟数据库实例

package/dist/database/types.d.ts

@@ -7,144 +7,3 @@ export type ClientDatabaseOutput<T> = {
     };
 };
 export type CloudDatabaseOutput<T> = T;
-export type DatabaseQueryCommand = {
-    _: never;
-};
-export type DatabaseMutateCommand = {
-    _: never;
-};
-/**
- * DatabaseCommand 数据库操作命令类型定义
- */
-export type DatabaseCommand = {
-    /**
-     * 聚合表达式操作符
-     * @param expr 表达式参数
-     * @returns 返回聚合表达式结果
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-expr expr 文档}
-     */
-    expr: (expr: unknown) => DatabaseQueryCommand;
-    /**
-     * 等于操作符
-     * @param value 比较值
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-eq eq 文档}
-     */
-    eq: (value: unknown) => DatabaseQueryCommand;
-    /**
-     * 不等于操作符
-     * @param value 比较值
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-neq neq 文档}
-     */
-    neq: (value: unknown) => DatabaseQueryCommand;
-    /**
-     * 大于操作符
-     * @param value 比较值
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-gt gt 文档}
-     */
-    gt: (value: unknown) => DatabaseQueryCommand;
-    /**
-     * 大于等于操作符
-     * @param value 比较值
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-gte gte 文档}
-     */
-    gte: (value: unknown) => DatabaseQueryCommand;
-    /**
-     * 小于操作符
-     * @param value 比较值
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-lt lt 文档}
-     */
-    lt: (value: unknown) => DatabaseQueryCommand;
-    /**
-     * 小于等于操作符
-     * @param value 比较值
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-lte lte 文档}
-     */
-    lte: (value: unknown) => DatabaseQueryCommand;
-    /**
-     * 包含在数组内操作符
-     * @param value 包含的值数组
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-in in 文档}
-     */
-    in: (value: unknown[]) => DatabaseQueryCommand;
-    /**
-     * 不包含在数组内操作符
-     * @param value 不包含的值数组
-     * @returns 返回查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-nin nin 文档}
-     */
-    nin: (value: unknown[]) => DatabaseQueryCommand;
-    /**
-     * 逻辑与操作符
-     * @param args 多个查询条件
-     * @returns 返回逻辑与查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-and and 文档}
-     */
-    and: (...args: unknown[]) => DatabaseQueryCommand;
-    /**
-     * 逻辑或操作符
-     * @param args 多个查询条件
-     * @returns 返回逻辑或查询条件
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#dbcmd-or or 文档}
-     */
-    or: (...args: unknown[]) => DatabaseQueryCommand;
-    /**
-     * 自增操作符
-     * @param value 增加的数值
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-inc inc 文档}
-     */
-    inc: (value: number) => DatabaseMutateCommand;
-    /**
-     * 自乘操作符
-     * @param value 相乘的数值
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-mul mul 文档}
-     */
-    mul: (value: number) => DatabaseMutateCommand;
-    /**
-     * 设置字段值操作符
-     * @param value 设置的值
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-set set 文档}
-     */
-    set: (value: unknown) => DatabaseMutateCommand;
-    /**
-     * 数组末尾添加元素操作符
-     * @param value 添加的值
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-push push 文档}
-     */
-    push: (value: unknown) => DatabaseMutateCommand;
-    /**
-     * 数组开头添加元素操作符
-     * @param value 添加的值
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-unshift unshift 文档}
-     */
-    unshift: (value: unknown) => DatabaseMutateCommand;
-    /**
-     * 删除数组末尾元素操作符
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-pop pop 文档}
-     */
-    pop: () => DatabaseMutateCommand;
-    /**
-     * 删除数组开头元素操作符
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-shift shift 文档}
-     */
-    shift: () => DatabaseMutateCommand;
-    /**
-     * 删除字段操作符
-     * @returns 返回更新操作
-     * @see {@link https://doc.dcloud.net.cn/uniCloud/cf-database.html#operator-remove remove 文档}
-     */
-    remove: () => DatabaseMutateCommand;
-};

package/dist/database/unique.d.ts

@@ -1,4 +1,4 @@
-import { DbCreate, DbSelect, DbUpdate, DbWhere } from './db.class';
+import { DbCreate, DbSelect, DbUpdate, DbWhere } from './_db.class';
 import { DbProxy } from './proxy';
 export type DbUniqueOptions<T, S extends DbSelect<T>, C extends DbCreate<T>, U extends DbUpdate<T>> = {
     /** 查询条件 */

package/dist/database/upsert.d.ts

@@ -1,5 +1,5 @@
 import { Exact } from '@cloudcome/utils-core/types';
-import { DbCreate, DbQuery, DbSelect, DbUpdate, DbWhere } from './db.class';
+import { DbCreate, DbQuery, DbSelect, DbUpdate, DbWhere } from './_db.class';
 import { DbProxy } from './proxy';
 export type DbUpsertOptions<T, S extends DbSelect<T>, C extends DbCreate<T>, U extends DbUpdate<T>> = {
     /** 查询条件 */
@@ -46,4 +46,4 @@ export type DbUpsertOutput = {
     /** 是否为更新操作 */
     updated: boolean;
 };
-export declare function dbUpsert<T, S extends DbSelect<T>, C extends DbCreate<T>, U extends DbUpdate<T>>(dbProxy: DbProxy<T>, options: DbUpsertOptions<T, S, C, U>): Promise<DbUpsertOutput>;
+export declare function dbUpsert<D1, S1 extends DbSelect<D1>, C extends DbCreate<D1>, U extends DbUpdate<D1>>(dbProxy: DbProxy<D1>, options: DbUpsertOptions<D1, S1, C, U>): Promise<DbUpsertOutput>;