@cloudcome/utils-uni 1.12.0 → 1.14.0

package/dist/database/command.d.ts

@@ -0,0 +1,122 @@
+import { DbMutateCommand, DbQueryCommand } from './_command.class';
+/**
+ * 数据库查询命令对象，提供各种查询操作符
+ */
+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 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

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

package/dist/database/transaction.d.ts

@@ -0,0 +1,23 @@
+import { Db } from './_db.class';
+import { DbProxy } from './proxy';
+type _WithTransaction = <D1>(table: DbProxy<D1>) => Db<D1>;
+/**
+ * 在数据库事务中执行操作
+ *
+ * @template K - 事务操作返回值类型
+ * @param transacting - 事务执行函数，接收事务数据库实例作为参数
+ * @param _mockDatabase - 用于测试的模拟数据库对象
+ * @param _mockDbInstance - 用于测试的模拟数据库实例
+ * @returns 事务操作的返回结果
+ *
+ * @example
+ * ```typescript
+ * const result = await dbTransaction(async (withTransaction) => {
+ *   const userId = await withTransaction(db.table('user')).create({ name: 'John' });
+ *   const order = await withTransaction(db.table('orders')).create({ userId, amount: 100 });
+ *   return { user, order };
+ * });
+ * ```
+ */
+export declare function dbTransaction<K>(transacting: (withTransaction: _WithTransaction) => Promise<K>, _mockDatabase?: any, _mockDbInstance?: any): Promise<K>;
+export {};

package/dist/database/types.d.ts

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

package/dist/database/unique.d.ts

@@ -0,0 +1,27 @@
+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>> = {
+    /** 查询条件 */
+    where: DbWhere<T>;
+    /** 创建数据 */
+    create: C;
+    /** 创建前回调函数 */
+    onBeforeCreate?: () => unknown;
+    /**
+     * 创建后回调函数
+     * @param id 创建的文档ID
+     */
+    onAfterCreate?: (id: string) => unknown;
+    /** 用于测试的模拟数据库实例 */
+    _mockDbInstance?: any;
+};
+/**
+ * 数据库 upsert 操作的返回结果类型
+ */
+export type DbUniqueOutput = {
+    /** 操作的文档ID */
+    id: string;
+    /** 是否为创建操作 */
+    created: boolean;
+};
+export declare function dbUnique<T, S extends DbSelect<T>, C extends DbCreate<T>, U extends DbUpdate<T>>(dbProxy: DbProxy<T>, options: DbUniqueOptions<T, S, C, U>): Promise<DbUniqueOutput>;

package/dist/database/{fns.d.ts → upsert.d.ts}

@@ -1,5 +1,6 @@
-import { AnyObject, Exact } from '@cloudcome/utils-core/types';
-import { Db, DbCreate, DbProxy, DbQuery, DbSelect, DbUpdate, DbWhere } from './db';
+import { Exact } from '@cloudcome/utils-core/types';
+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>> = {
     /** 查询条件 */
     where: DbWhere<T>;
@@ -45,25 +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>;
-type _WithTransaction = <T, S extends DbSelect<T>, R extends AnyObject>(table: DbProxy<T, S, R>) => Db<T, S, R>;
-/**
- * 在数据库事务中执行操作
- *
- * @template T - 事务操作返回值类型
- * @param transacting - 事务执行函数，接收事务数据库实例作为参数
- * @param _mockDatabase - 用于测试的模拟数据库对象
- * @param _mockDbInstance - 用于测试的模拟数据库实例
- * @returns 事务操作的返回结果
- *
- * @example
- * ```typescript
- * const result = await dbTransaction(async (withTransaction) => {
- *   const userId = await withTransaction(db.table('user')).create({ name: 'John' });
- *   const order = await withTransaction(db.table('orders')).create({ userId, amount: 100 });
- *   return { user, order };
- * });
- * ```
- */
-export declare function dbTransaction<K>(transacting: (withTransaction: _WithTransaction) => Promise<K>, _mockDatabase?: any, _mockDbInstance?: any): Promise<K>;
-export {};
+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>;