@cloudcome/utils-uni 1.13.0 → 1.15.0

package/dist/database.mjs

@@ -1,53 +1,195 @@
-import { isString, isNumber, isArray, isFunction } from "@cloudcome/utils-core/type";
+import { isString, isNumber, isArray, isObject, isFunction } from "@cloudcome/utils-core/type";
 import { a as parseDatabaseOutput } from "./_helpers.mjs";
+import { c as createCloudObjectError } from "./error.mjs";
 import { objectMap, objectEach } from "@cloudcome/utils-core/object";
 import { tryFlatten } from "@cloudcome/utils-core/try";
-const dbCmd = uniCloud.database().command;
+class DbBaseCommand {
+  command;
+  parameter;
+  isQuery = false;
+  isMutate = false;
+  constructor(command, parameter) {
+    this.command = command;
+    this.parameter = parameter;
+  }
+  getValue(db) {
+    return db.command[this.command].call(
+      db.command,
+      this.parameter
+    );
+  }
+  getExpression(fieldName) {
+    return {
+      [`$${this.command}`]: [fieldName, this.parameter]
+    };
+  }
+}
+class DbQueryCommand extends DbBaseCommand {
+  isQuery = true;
+}
+class DbMutateCommand extends DbBaseCommand {
+  isMutate = true;
+}
+const dbQuery = {
+  /**
+   * 等于操作符
+   * @param value 比较值
+   * @returns DbQueryCommand 查询命令对象
+   */
+  eq: (value) => new DbQueryCommand("eq", value),
+  /**
+   * 不等于操作符
+   * @param value 比较值
+   * @returns DbQueryCommand 查询命令对象
+   */
+  neq: (value) => new DbQueryCommand("neq", value),
+  /**
+   * 大于操作符
+   * @param value 比较值
+   * @returns DbQueryCommand 查询命令对象
+   */
+  gt: (value) => new DbQueryCommand("gt", value),
+  /**
+   * 大于等于操作符
+   * @param value 比较值
+   * @returns DbQueryCommand 查询命令对象
+   */
+  gte: (value) => new DbQueryCommand("gte", value),
+  /**
+   * 小于操作符
+   * @param value 比较值
+   * @returns DbQueryCommand 查询命令对象
+   */
+  lt: (value) => new DbQueryCommand("lt", value),
+  /**
+   * 小于等于操作符
+   * @param value 比较值
+   * @returns DbQueryCommand 查询命令对象
+   */
+  lte: (value) => new DbQueryCommand("lte", value),
+  /**
+   * 包含在数组中操作符
+   * @param value 值数组
+   * @returns DbQueryCommand 查询命令对象
+   */
+  in: (value) => new DbQueryCommand("in", value),
+  /**
+   * 不包含在数组中操作符
+   * @param value 值数组
+   * @returns DbQueryCommand 查询命令对象
+   */
+  nin: (value) => new DbQueryCommand("nin", value),
+  /**
+   * 逻辑与操作符
+   * @param conditions 查询条件参数
+   * @returns DbQueryCommand 查询命令对象
+   */
+  and: (conditions) => new DbQueryCommand("and", conditions),
+  /**
+   * 逻辑或操作符
+   * @param conditions 查询条件参数
+   * @returns DbQueryCommand 查询命令对象
+   */
+  or: (conditions) => new DbQueryCommand("or", conditions),
+  /**
+   * 数组长度匹配操作符
+   * @param size 数组长度
+   * @returns DbQueryCommand 查询命令对象
+   */
+  size: (size) => new DbQueryCommand("size", size)
+};
+const dbMutate = {
+  /**
+   * 数值增加操作符
+   * @param value 增加的数值
+   * @returns DbMutateCommand 变更命令对象
+   */
+  inc: (value) => new DbMutateCommand("inc", value),
+  /**
+   * 数值乘法操作符
+   * @param value 乘数
+   * @returns DbMutateCommand 变更命令对象
+   */
+  mul: (value) => new DbMutateCommand("mul", value),
+  /**
+   * 设置字段值操作符
+   * @param value 设置的值
+   * @returns DbMutateCommand 变更命令对象
+   */
+  set: (value) => new DbMutateCommand("set", value),
+  /**
+   * 向数组末尾添加元素操作符
+   * @param value 添加的值
+   * @returns DbMutateCommand 变更命令对象
+   */
+  push: (value) => new DbMutateCommand("push", value),
+  /**
+   * 向数组开头添加元素操作符
+   * @param value 添加的值
+   * @returns DbMutateCommand 变更命令对象
+   */
+  unshift: (value) => new DbMutateCommand("unshift", value),
+  /**
+   * 从数组末尾移除元素操作符
+   * @returns DbMutateCommand 变更命令对象
+   */
+  pop: () => new DbMutateCommand("pop", void 0),
+  /**
+   * 从数组开头移除元素操作符
+   * @returns DbMutateCommand 变更命令对象
+   */
+  shift: () => new DbMutateCommand("shift", void 0),
+  /**
+   * 移除字段操作符
+   * @returns DbMutateCommand 变更命令对象
+   */
+  remove: () => new DbMutateCommand("remove", void 0)
+};
 const dbAgg = uniCloud.database().command.aggregate;
 const db0 = uniCloud.database();
 let gid = 0;
 class Db {
-  #host;
+  _host;
   /**
    * 是否为事务环境
    * - 查询条件只能是 id
    * - 不能聚合操作
    */
-  #isTransaction = false;
-  #options;
+  _isTransaction = false;
+  _options;
   /**
    * 构造函数，初始化数据库集合引用
    * @param collection 数据表名称
    * @param _mockDatabase 模拟数据库，用于单元测试
    */
   constructor(options) {
-    this.#options = options;
-    this.#host = options._mockDatabase || options.transaction?.collection(options.table) || db0.collection(options.table);
-    this.#isTransaction = !!options.transaction;
+    this._options = options;
+    this._host = options._mockDatabase || options.transaction?.collection(options.table) || db0.collection(options.table);
+    this._isTransaction = !!options.transaction;
   }
   get table() {
-    return this.#options.table;
+    return this._options.table;
   }
   /**
    * 获取聚合操作实例
    * @returns 聚合操作实例
    */
   aggregate() {
-    return this.#host.aggregate();
+    return this._host.aggregate();
   }
-  #hasWhere = void 0;
-  #hasWhereId = void 0;
-  #where = {};
-  #doWhere(where, from) {
-    if (this.#hasWhere) throw new Error(`已调用过一次 db.${_toWhereMethod(this.#hasWhere)} 了`);
+  _hasWhere = void 0;
+  _hasWhereId = void 0;
+  _where = {};
+  _doWhere(where, from) {
+    if (this._hasWhere) throw new Error(`已调用过一次 db.${_toWhereMethod(this._hasWhere)} 了`);
     const whereKeys = Object.keys(where);
     const isWhereId = whereKeys.length === 1 && "_id" in where && (isString(where._id) || isNumber(where._id));
-    if (isWhereId && this.#hasLimit) {
+    if (isWhereId && this._hasLimit) {
       throw new Error(`db.${_toWhereIdMethod(from)} 方法不能与 db.limit() 方法同时调用`);
     }
-    this.#hasWhere = from;
-    this.#where = where;
-    if (isWhereId) this.#hasWhereId = from;
+    this._hasWhere = from;
+    this._where = where;
+    if (isWhereId) this._hasWhereId = from;
     return this;
   }
   /**
@@ -56,7 +198,7 @@ class Db {
    * @returns 当前Db实例，支持链式调用
    */
   where(where) {
-    return this.#doWhere(where, "where");
+    return this._doWhere(where, "where");
   }
   /**
    * 根据ID设置查询条件
@@ -64,102 +206,100 @@ class Db {
    * @returns 当前Db实例，支持链式调用
    */
   whereId(id) {
-    return this.#doWhere({ _id: id }, "whereId");
+    return this._doWhere({ _id: id }, "whereId");
   }
-  #hasSelect = 0;
-  #select = {};
+  _hasSelect = 0;
+  _select = {};
   /**
    * 指定要返回的字段
    * @param fields 要返回的字段对象，true表示返回，false表示不返回
    * @returns 当前Db实例，支持链式调用
    */
   select(fields) {
-    if (this.#hasSelect) throw new Error("db.select() 方法只能调用一次");
-    this.#hasSelect++;
-    this.#select = fields;
+    if (this._hasSelect) throw new Error("db.select() 方法只能调用一次");
+    this._hasSelect++;
+    this._select = fields;
     return this;
   }
-  #hasOrder = 0;
-  #order = {};
+  _hasOrder = 0;
+  _order = {};
   /**
    * 设置排序规则
    * @param order 排序规则对象，key为字段名，value为"asc"或"desc"
    * @returns 当前Db实例，支持链式调用
    */
   order(order) {
-    this.#hasOrder++;
-    this.#order = order;
+    this._hasOrder++;
+    this._order = order;
     return this;
   }
-  #hasSkip = 0;
-  #skip = 0;
+  _hasSkip = 0;
+  _skip = 0;
   /**
    * 跳过指定数量的记录
    * @param skip 要跳过的记录数
    * @returns 当前Db实例，支持链式调用
    */
   skip(skip) {
-    if (this.#hasSkip) throw new Error("db.skip() 方法只能调用一次");
-    this.#hasSkip++;
-    this.#skip = skip;
+    if (this._hasSkip) throw new Error("db.skip() 方法只能调用一次");
+    this._hasSkip++;
+    this._skip = skip;
     return this;
   }
-  #hasLimit = 0;
-  #limit = 0;
+  _hasLimit = 0;
+  _limit = 0;
   /**
    * 限制返回的记录数量
    * @param limit 最大返回记录数
    * @returns 当前Db实例，支持链式调用
    */
   limit(limit) {
-    if (this.#hasLimit) throw new Error("db.limit() 方法只能调用一次");
-    if (this.#hasWhereId) {
-      throw new Error(`db.limit() 方法不能与 ${_toWhereIdMethod(this.#hasWhereId)} 方法同时调用`);
+    if (this._hasLimit) throw new Error("db.limit() 方法只能调用一次");
+    if (this._hasWhereId) {
+      throw new Error(`db.limit() 方法不能与 ${_toWhereIdMethod(this._hasWhereId)} 方法同时调用`);
     }
-    this.#hasLimit++;
-    this.#limit = limit;
+    this._hasLimit++;
+    this._limit = limit;
     return this;
   }
-  #hasLookup = 0;
+  _hasLookup = 0;
   get hasLookup() {
-    return this.#hasLookup > 0;
+    return this._hasLookup > 0;
   }
-  #lookups = [];
+  _lookups = [];
   lookup(table, lookup) {
-    table.#hasLookup++;
-    this.#hasLookup++;
-    this.#lookups.push({
+    table._hasLookup++;
+    this._hasLookup++;
+    this._lookups.push({
       ...lookup,
-      table,
-      from: table.table
+      table
     });
     return this;
   }
-  #aggregated = false;
-  #endAggregate(aggRef) {
-    if (this.#aggregated) throw new Error(`相同的数据表实例(${this.table})不能重复使用`);
-    this.#aggregated = true;
+  _aggregated = false;
+  _endAggregate(aggRef) {
+    if (this._aggregated) throw new Error(`相同的数据表实例(${this.table})不能重复使用`);
+    this._aggregated = true;
     let returnAggRef = aggRef;
     const projects = {};
-    for (const { type, as, foreignField, from, localField, table } of this.#lookups) {
-      const varName = `v${gid++}`;
+    for (const { type, as, foreignField, localField, table, unselect } of this._lookups) {
+      const letName = `let${gid++}`;
       let pipeline = dbAgg.pipeline();
-      pipeline = pipeline.match(
-        dbCmd.expr(
-          type === "n:1" ? (
-            // @ts-ignore
-            dbAgg.in([`$${foreignField}`, `$$${varName}`])
-          ) : dbAgg.eq([`$${foreignField}`, `$$${varName}`])
-        )
-      );
-      pipeline = table.#endAggregate(pipeline);
+      pipeline = pipeline.match({
+        $expr: {
+          $and: [
+            type === "n:1" ? { $in: [`$${foreignField}`, `$$${letName}`] } : { $eq: [`$${foreignField}`, `$$${letName}`] }
+          ]
+        }
+      });
+      pipeline = table._endAggregate(pipeline);
       pipeline = pipeline.done();
       returnAggRef = returnAggRef.lookup({
         let: {
-          [varName]: `$${localField}`
+          [letName]: `$${localField}`
         },
         as,
-        from,
+        from: table.table,
         pipeline
       });
       if (type === "1:1") {
@@ -168,30 +308,30 @@ class Db {
           preserveNullAndEmptyArrays: true
         });
       }
-      projects[as] = true;
+      if (as && !unselect) projects[as] = true;
     }
-    if (this.#hasWhere) returnAggRef = returnAggRef.match(this.#where);
-    if (this.#hasSelect) returnAggRef = returnAggRef.project({ ...this.#select, ...projects });
-    if (this.#hasOrder) returnAggRef = returnAggRef.sort(objectMap(this.#order, (v) => v === "asc" ? 1 : -1));
-    if (this.#hasSkip) returnAggRef = returnAggRef.skip(this.#skip);
-    if (this.#hasLimit) returnAggRef = returnAggRef.limit(this.#limit);
+    if (this._hasWhere) returnAggRef = returnAggRef.match(_mapCommandRaw(this._where));
+    if (this._hasSelect) returnAggRef = returnAggRef.project({ ...this._select, ...projects });
+    if (this._hasOrder) returnAggRef = returnAggRef.sort(objectMap(this._order, (v) => v === "asc" ? 1 : -1));
+    if (this._hasSkip) returnAggRef = returnAggRef.skip(this._skip);
+    if (this._hasLimit) returnAggRef = returnAggRef.limit(this._limit);
     return returnAggRef;
   }
-  #endHost() {
-    if (this.#hasWhere) {
-      this.#host = this.#host.where(this.#where);
+  _endHost() {
+    if (this._hasWhere) {
+      this._host = this._host.where(_mapCommandRaw(this._where));
     }
-    if (this.#hasSelect) {
-      this.#host = this.#host.field(this.#select);
+    if (this._hasSelect) {
+      this._host = this._host.field(this._select);
     }
-    if (this.#hasOrder) {
-      objectEach(this.#order, (val, key) => {
-        this.#host = this.#host.orderBy(key, val);
+    if (this._hasOrder) {
+      objectEach(this._order, (val, key) => {
+        this._host = this._host.orderBy(key, val);
       });
     }
-    if (this.#hasSkip) this.#host = this.#host.skip(this.#skip);
-    if (this.#hasLimit) this.#host = this.#host.limit(this.#limit);
-    else if (this.#hasWhereId) this.#host = this.#host.limit(1);
+    if (this._hasSkip) this._host = this._host.skip(this._skip);
+    if (this._hasLimit) this._host = this._host.limit(this._limit);
+    else if (this._hasWhereId) this._host = this._host.limit(1);
   }
   /**
    * 执行查询操作
@@ -199,38 +339,38 @@ class Db {
    */
   async query() {
     let res;
-    if (this.#hasLookup) {
+    if (this._hasLookup) {
       const aggRef = this.aggregate();
-      this.#endAggregate(aggRef);
+      this._endAggregate(aggRef);
       res = await aggRef.end();
     } else {
-      this.#endHost();
-      res = await this.#host.get();
+      this._endHost();
+      res = await this._host.get();
     }
     isArray(res.data) ? res.data : [res.data];
     const { data } = parseDatabaseOutput(res);
     return data;
   }
-  async queryOne(ignoreMiss = false) {
-    if (this.#hasLimit) throw new Error("db.queryOne() 方法不支持 limit 条件");
-    if (!this.#hasWhereId) this.limit(1);
+  async queryOne(allowMiss = false) {
+    if (this._hasLimit) throw new Error("db.queryOne() 方法不支持 limit 条件");
+    if (!this._hasWhereId) this.limit(1);
     const data = await this.query();
     const res = data.at(0);
-    if (!ignoreMiss && !res) throw new Error("未找到匹配记录");
-    return res;
+    if (!allowMiss && !res) throw createCloudObjectError("查询数据为空", "queryOneNotFound");
+    return res || null;
   }
   /**
    * 获取匹配记录的数量
    * @returns 记录总数
    */
   async count() {
-    if (this.#hasLookup) throw new Error("db.count() 方法不支持 lookup 聚合");
-    if (this.#hasSelect) throw new Error("db.count() 方法不支持 select 条件");
-    if (this.#hasOrder) throw new Error("db.count() 方法不支持 order 条件");
-    if (this.#hasSkip) throw new Error("db.count() 方法不支持 skip 条件");
-    if (this.#hasLimit) throw new Error("db.count() 方法不支持 limit 条件");
-    this.#endHost();
-    const res = await this.#host.count();
+    if (this._hasLookup) throw new Error("db.count() 方法不支持 lookup 聚合");
+    if (this._hasSelect) throw new Error("db.count() 方法不支持 select 条件");
+    if (this._hasOrder) throw new Error("db.count() 方法不支持 order 条件");
+    if (this._hasSkip) throw new Error("db.count() 方法不支持 skip 条件");
+    if (this._hasLimit) throw new Error("db.count() 方法不支持 limit 条件");
+    this._endHost();
+    const res = await this._host.count();
     const { total } = parseDatabaseOutput(res);
     return total;
   }
@@ -240,14 +380,14 @@ class Db {
    * @returns 创建结果
    */
   async create(data) {
-    if (this.#hasLookup) throw new Error("db.create() 方法不支持 lookup 聚合");
-    if (this.#hasWhere) throw new Error("db.create() 方法不支持 where 条件");
-    if (this.#hasSelect) throw new Error("db.create() 方法不支持 select 条件");
-    if (this.#hasOrder) throw new Error("db.create() 方法不支持 order 条件");
-    if (this.#hasSkip) throw new Error("db.create() 方法不支持 skip 条件");
-    if (this.#hasLimit) throw new Error("db.create() 方法不支持 limit 条件");
-    this.#endHost();
-    const res = await this.#host.add(data);
+    if (this._hasLookup) throw new Error("db.create() 方法不支持 lookup 聚合");
+    if (this._hasWhere) throw new Error("db.create() 方法不支持 where 条件");
+    if (this._hasSelect) throw new Error("db.create() 方法不支持 select 条件");
+    if (this._hasOrder) throw new Error("db.create() 方法不支持 order 条件");
+    if (this._hasSkip) throw new Error("db.create() 方法不支持 skip 条件");
+    if (this._hasLimit) throw new Error("db.create() 方法不支持 limit 条件");
+    this._endHost();
+    const res = await this._host.add(data);
     const { id } = parseDatabaseOutput(res);
     return id;
   }
@@ -257,15 +397,15 @@ class Db {
    * @returns 更新结果
    */
   async update(data) {
-    if (this.#hasLookup) throw new Error("db.update() 方法不支持 lookup 聚合");
-    if (!this.#hasWhere) throw new Error("设置 where 条件后才能执行 db.update() 方法");
-    if (this.#hasSelect) throw new Error("db.update() 方法不支持 select 条件");
-    if (this.#hasOrder) throw new Error("db.update() 方法不支持 order 条件");
-    if (this.#hasSkip) throw new Error("db.update() 方法不支持 skip 条件");
-    if (this.#hasLimit) throw new Error("db.update() 方法不支持 limit 条件");
-    if (this.#isTransaction && !this.#hasWhereId) throw new Error("事务模式下 db.update() 的 where 条件必须是 _id");
-    this.#endHost();
-    const res = await this.#host.update(data);
+    if (this._hasLookup) throw new Error("db.update() 方法不支持 lookup 聚合");
+    if (!this._hasWhere) throw new Error("设置 where 条件后才能执行 db.update() 方法");
+    if (this._hasSelect) throw new Error("db.update() 方法不支持 select 条件");
+    if (this._hasOrder) throw new Error("db.update() 方法不支持 order 条件");
+    if (this._hasSkip) throw new Error("db.update() 方法不支持 skip 条件");
+    if (this._hasLimit) throw new Error("db.update() 方法不支持 limit 条件");
+    if (this._isTransaction && !this._hasWhereId) throw new Error("事务模式下 db.update() 的 where 条件必须是 _id");
+    this._endHost();
+    const res = await this._host.update(_mapCommandRaw(data));
     const { updated } = parseDatabaseOutput(res);
     return updated;
   }
@@ -274,15 +414,15 @@ class Db {
    * @returns 删除结果
    */
   async remove() {
-    if (this.#hasLookup) throw new Error("db.remove() 方法不支持 lookup 聚合");
-    if (!this.#hasWhere) throw new Error("设置 where 条件后才能执行 db.remove() 方法");
-    if (this.#hasSelect) throw new Error("db.remove() 方法不支持 select 条件");
-    if (this.#hasOrder) throw new Error("db.remove() 方法不支持 order 条件");
-    if (this.#hasSkip) throw new Error("db.remove() 方法不支持 skip 条件");
-    if (this.#hasLimit) throw new Error("db.remove() 方法不支持 limit 条件");
-    if (this.#isTransaction && !this.#hasWhereId) throw new Error("事务模式下 db.remove() 的 where 条件必须是 _id");
-    this.#endHost();
-    const res = await this.#host.remove();
+    if (this._hasLookup) throw new Error("db.remove() 方法不支持 lookup 聚合");
+    if (!this._hasWhere) throw new Error("设置 where 条件后才能执行 db.remove() 方法");
+    if (this._hasSelect) throw new Error("db.remove() 方法不支持 select 条件");
+    if (this._hasOrder) throw new Error("db.remove() 方法不支持 order 条件");
+    if (this._hasSkip) throw new Error("db.remove() 方法不支持 skip 条件");
+    if (this._hasLimit) throw new Error("db.remove() 方法不支持 limit 条件");
+    if (this._isTransaction && !this._hasWhereId) throw new Error("事务模式下 db.remove() 的 where 条件必须是 _id");
+    this._endHost();
+    const res = await this._host.remove();
     const { deleted } = parseDatabaseOutput(res);
     return deleted;
   }
@@ -293,6 +433,11 @@ function _toWhereMethod(whereFrom) {
 function _toWhereIdMethod(whereFrom) {
   return whereFrom === "where" ? "where({ _id })" : "whereId(id)";
 }
+function _mapCommandRaw(where) {
+  return objectMap(where, (val, key) => {
+    return isObject(val) && val instanceof DbBaseCommand ? val.getValue(db0) : val;
+  });
+}
 function dbProxy(name) {
   return new Proxy(
     {},
@@ -364,9 +509,9 @@ async function dbTransaction(transacting, _mockDatabase, _mockDbInstance) {
   return result;
 }
 export {
-  dbAgg,
-  dbCmd,
+  dbMutate,
   dbProxy,
+  dbQuery,
   dbTransaction,
   dbUnique,
   dbUpsert,