@cloudcome/utils-uni 1.12.0 → 1.14.0

package/dist/database.cjs

@@ -1,55 +1,194 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const error = require("@cloudcome/utils-core/error");
-const object = require("@cloudcome/utils-core/object");
 const type = require("@cloudcome/utils-core/type");
+const _helpers = require("./_helpers.cjs");
+const object = require("@cloudcome/utils-core/object");
 const _try = require("@cloudcome/utils-core/try");
+class DbBaseCommand {
+  command;
+  parameter;
+  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 {
+  isQueryCommand = true;
+}
+class DbMutateCommand extends DbBaseCommand {
+  isMutateCommand = 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();
-const dbCmd = db0.command;
-const dbAgg = db0.command.aggregate;
 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 && (type.isString(where._id) || type.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;
   }
   /**
@@ -58,7 +197,7 @@ class Db {
    * @returns 当前Db实例，支持链式调用
    */
   where(where) {
-    return this.#doWhere(where, "where");
+    return this._doWhere(where, "where");
   }
   /**
    * 根据ID设置查询条件
@@ -66,102 +205,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: type2, as, foreignField, from, localField, table } of this.#lookups) {
-      const varName = `v${gid++}`;
+    for (const { type: type2, as, foreignField, localField, table, unselect } of this._lookups) {
+      const letName = `let${gid++}`;
       let pipeline = dbAgg.pipeline();
-      pipeline = pipeline.match(
-        dbCmd.expr(
-          type2 === "n:1" ? (
-            // @ts-ignore
-            dbAgg.in([`$${foreignField}`, `$$${varName}`])
-          ) : dbAgg.eq([`$${foreignField}`, `$$${varName}`])
-        )
-      );
-      pipeline = table.#endAggregate(pipeline);
+      pipeline = pipeline.match({
+        $expr: {
+          $and: [
+            type2 === "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 (type2 === "1:1") {
@@ -170,30 +307,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(object.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(_mapQueryCommandWhere(this._where));
+    if (this._hasSelect) returnAggRef = returnAggRef.project({ ...this._select, ...projects });
+    if (this._hasOrder) returnAggRef = returnAggRef.sort(object.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(_mapQueryCommandWhere(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) {
-      object.objectEach(this.#order, (val, key) => {
-        this.#host = this.#host.orderBy(key, val);
+    if (this._hasOrder) {
+      object.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);
   }
   /**
    * 执行查询操作
@@ -201,24 +338,24 @@ 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();
     }
     type.isArray(res.data) ? res.data : [res.data];
-    const { data } = parseDatabaseOutput(res);
+    const { data } = _helpers.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("未找到匹配记录");
+    if (!allowMiss && !res) throw new Error("未找到匹配记录");
     return res;
   }
   /**
@@ -226,14 +363,14 @@ class Db {
    * @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();
-    const { total } = parseDatabaseOutput(res);
+    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 } = _helpers.parseDatabaseOutput(res);
     return total;
   }
   /**
@@ -242,15 +379,15 @@ 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);
-    const { id } = parseDatabaseOutput(res);
+    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 } = _helpers.parseDatabaseOutput(res);
     return id;
   }
   /**
@@ -259,16 +396,16 @@ 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);
-    const { updated } = parseDatabaseOutput(res);
+    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);
+    const { updated } = _helpers.parseDatabaseOutput(res);
     return updated;
   }
   /**
@@ -276,58 +413,45 @@ 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();
-    const { deleted } = parseDatabaseOutput(res);
+    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 } = _helpers.parseDatabaseOutput(res);
     return deleted;
   }
 }
-const db = {
-  /**
-   * 获取指定名称的数据库集合实例
-   * @param name 数据表名称
-   * @returns Db类实例，用于执行数据库操作
-   */
-  // biome-ignore lint/complexity/noBannedTypes: <explanation>
-  table(name) {
-    return new Proxy(
-      {},
-      {
-        get(target, prop) {
-          if (prop === "_isProxy") return true;
-          const table = new Db({ table: name });
-          const tableProp = prop;
-          const ref = table[tableProp];
-          return type.isFunction(ref) ? ref.bind(table) : ref;
-        }
-      }
-    );
-  }
-};
-function parseDatabaseOutput(res) {
-  const keys = Object.keys(res);
-  const isClient = keys.length === 1 && keys[0] === "result";
-  if (isClient) {
-    const { result } = res;
-    if (!result.errCode) return object.objectOmit(result, ["errCode", "errMsg", "code", "message"]);
-    throw error.errorAssign(new Error(result.errMsg), result);
-  }
-  return res;
-}
 function _toWhereMethod(whereFrom) {
   return whereFrom === "where" ? "where({...})" : "whereId(id)";
 }
 function _toWhereIdMethod(whereFrom) {
   return whereFrom === "where" ? "where({ _id })" : "whereId(id)";
 }
-async function dbUpsert(dbProxy, options) {
+function _mapQueryCommandWhere(where) {
+  return object.objectMap(where, (val, key) => {
+    return type.isObject(val) && val instanceof DbQueryCommand ? val.getValue(db0) : val;
+  });
+}
+function dbProxy(name) {
+  return new Proxy(
+    {},
+    {
+      get(target, prop) {
+        if (prop === "_isProxy") return true;
+        const table = new Db({ table: name });
+        const tableProp = prop;
+        const ref = table[tableProp];
+        return type.isFunction(ref) ? ref.bind(table) : ref;
+      }
+    }
+  );
+}
+async function dbUpsert(dbProxy2, options) {
   const {
     where,
     select = {},
@@ -340,7 +464,7 @@ async function dbUpsert(dbProxy, options) {
     _mockDbInstance
   } = options;
   if ("_id" in select) throw new Error("select 条件不能包含 _id 字段");
-  const _db = _mockDbInstance || dbProxy;
+  const _db = _mockDbInstance || dbProxy2;
   const exist = await _db.where(where).select(select || {}).queryOne(true);
   if (exist) {
     const skipUpdate = await onBeforeUpdate?.(exist) === false;
@@ -357,12 +481,20 @@ async function dbUpsert(dbProxy, options) {
   await onAfterCreate?.(createdId);
   return { id: createdId, updated: false, created: true };
 }
+async function dbUnique(dbProxy2, options) {
+  const { id, created } = await dbUpsert(dbProxy2, {
+    ...options,
+    update: {},
+    onBeforeUpdate: () => false
+  });
+  return { id, created };
+}
 async function dbTransaction(transacting, _mockDatabase, _mockDbInstance) {
   const transactionDb = _mockDatabase || uniCloud.database();
   const [err1, transaction] = await _try.tryFlatten(transactionDb.startTransaction());
   if (err1) throw err1;
-  const withTransaction = (dbProxy) => {
-    return _mockDbInstance || new Db({ table: dbProxy.table, transaction });
+  const withTransaction = (dbProxy2) => {
+    return _mockDbInstance || new Db({ table: dbProxy2.table, transaction });
   };
   const [err2, result] = await _try.tryFlatten(async () => {
     const result2 = await transacting(withTransaction);
@@ -375,11 +507,11 @@ async function dbTransaction(transacting, _mockDatabase, _mockDbInstance) {
   }
   return result;
 }
-exports.Db = Db;
-exports.db = db;
-exports.dbAgg = dbAgg;
-exports.dbCmd = dbCmd;
+exports.parseDatabaseOutput = _helpers.parseDatabaseOutput;
+exports.dbMutate = dbMutate;
+exports.dbProxy = dbProxy;
+exports.dbQuery = dbQuery;
 exports.dbTransaction = dbTransaction;
+exports.dbUnique = dbUnique;
 exports.dbUpsert = dbUpsert;
-exports.parseDatabaseOutput = parseDatabaseOutput;
 //# sourceMappingURL=database.cjs.map