@cloudcome/utils-uni 1.41.0 → 1.43.0

package/dist/_helpers.cjs

@@ -28,7 +28,25 @@ function parseDatabaseOutput(res) {
 	}
 	return res;
 }
+/**
+* 检查给定的未知值是否为 UniError 类型。
+*
+* 该函数作为 TypeScript 的类型守卫（Type Guard），在运行时验证传入的对象是否为 Error 的实例，
+* 并在类型系统中将未知类型（unknown）收窄为 UniError 类型。
+*
+* @param {unknown} err - 需要检查的未知值。
+* @returns {boolean} 如果传入的值是 Error 的实例，则返回 true，否则返回 false。
+*/
+function isUniError(err) {
+	return err instanceof Error;
+}
 //#endregion
+Object.defineProperty(exports, "isUniError", {
+	enumerable: true,
+	get: function() {
+		return isUniError;
+	}
+});
 Object.defineProperty(exports, "parseCloudMethodOutput", {
 	enumerable: true,
 	get: function() {

package/dist/_helpers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"_helpers.cjs","names":[],"sources":["../src/_helpers.ts"],"sourcesContent":["import { errorAssign } from '@cloudcome/utils-core/error';\nimport { objectOmit } from '@cloudcome/utils-core/object';\nimport type { CloudMethodOutput } from './cloud';\nimport type { ClientDatabaseOutput, CloudDatabaseOutput } from './database';\n\n/**\n * 解析云对象方法调用的输出结果\n *\n * @template O - 云对象方法返回数据的类型\n * @param output - 云对象方法调用的输出结果\n * @param fallbackErrorMessage - 当输出中没有错误信息时使用的默认错误消息\n * @returns 云对象方法返回成功时的数据部分\n * @throws 当云对象方法调用失败时，抛出包含错误信息的异常\n */\nexport function parseCloudMethodOutput<O>(output: CloudMethodOutput<O>, fallbackErrorMessage = ''): O {\n  if (output.errCode) {\n    throw errorAssign(new Error(output.errMsg || fallbackErrorMessage), output);\n  }\n\n  return output.data;\n}\n\n/**\n * 解析数据库执行结果\n * @param res 客户端、云端响应结果\n * @returns 处理后的结果\n */\nexport function parseDatabaseOutput<T>(res: ClientDatabaseOutput<T> | CloudDatabaseOutput<T>) {\n  const keys = Object.keys(res as AnyObject);\n  // 客户端 { result: {errCode: 0, errMsg: 'ok'} & 数据 }\n  const isClient = keys.length === 1 && keys[0] === 'result';\n\n  if (isClient) {\n    const { result } = res as ClientDatabaseOutput<T>;\n    if (!result.errCode) return objectOmit(result, ['errCode', 'errMsg']);\n    throw errorAssign(new Error(result.errMsg), result);\n  }\n\n  // 云端 数据\n  return res as T;\n}\n"],"mappings":";;;;;;;;;;;;AAcA,SAAgB,uBAA0B,QAA8B,uBAAuB,IAAO;CACpG,IAAI,OAAO,SACT,OAAA,GAAA,4BAAA,aAAkB,IAAI,MAAM,OAAO,UAAU,oBAAoB,GAAG,MAAM;CAG5E,OAAO,OAAO;AAChB;;;;;;AAOA,SAAgB,oBAAuB,KAAuD;CAC5F,MAAM,OAAO,OAAO,KAAK,GAAgB;CAIzC,IAFiB,KAAK,WAAW,KAAK,KAAK,OAAO,UAEpC;EACZ,MAAM,EAAE,WAAW;EACnB,IAAI,CAAC,OAAO,SAAS,QAAA,GAAA,6BAAA,YAAkB,QAAQ,CAAC,WAAW,QAAQ,CAAC;EACpE,OAAA,GAAA,4BAAA,aAAkB,IAAI,MAAM,OAAO,MAAM,GAAG,MAAM;CACpD;CAGA,OAAO;AACT"}
+{"version":3,"file":"_helpers.cjs","names":[],"sources":["../src/_helpers.ts"],"sourcesContent":["import { errorAssign } from '@cloudcome/utils-core/error';\nimport { objectOmit } from '@cloudcome/utils-core/object';\nimport type { CloudMethodOutput } from './cloud';\nimport type { ClientDatabaseOutput, CloudDatabaseOutput } from './database';\nimport type { UniError } from './_types';\n\n/**\n * 解析云对象方法调用的输出结果\n *\n * @template O - 云对象方法返回数据的类型\n * @param output - 云对象方法调用的输出结果\n * @param fallbackErrorMessage - 当输出中没有错误信息时使用的默认错误消息\n * @returns 云对象方法返回成功时的数据部分\n * @throws 当云对象方法调用失败时，抛出包含错误信息的异常\n */\nexport function parseCloudMethodOutput<O>(output: CloudMethodOutput<O>, fallbackErrorMessage = ''): O {\n  if (output.errCode) {\n    throw errorAssign(new Error(output.errMsg || fallbackErrorMessage), output);\n  }\n\n  return output.data;\n}\n\n/**\n * 解析数据库执行结果\n * @param res 客户端、云端响应结果\n * @returns 处理后的结果\n */\nexport function parseDatabaseOutput<T>(res: ClientDatabaseOutput<T> | CloudDatabaseOutput<T>) {\n  const keys = Object.keys(res as AnyObject);\n  // 客户端 { result: {errCode: 0, errMsg: 'ok'} & 数据 }\n  const isClient = keys.length === 1 && keys[0] === 'result';\n\n  if (isClient) {\n    const { result } = res as ClientDatabaseOutput<T>;\n    if (!result.errCode) return objectOmit(result, ['errCode', 'errMsg']);\n    throw errorAssign(new Error(result.errMsg), result);\n  }\n\n  // 云端 数据\n  return res as T;\n}\n\n/**\n * 检查给定的未知值是否为 UniError 类型。\n *\n * 该函数作为 TypeScript 的类型守卫（Type Guard），在运行时验证传入的对象是否为 Error 的实例，\n * 并在类型系统中将未知类型（unknown）收窄为 UniError 类型。\n *\n * @param {unknown} err - 需要检查的未知值。\n * @returns {boolean} 如果传入的值是 Error 的实例，则返回 true，否则返回 false。\n */\nexport function isUniError(err: unknown): err is UniError {\n  return err instanceof Error;\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,uBAA0B,QAA8B,uBAAuB,IAAO;CACpG,IAAI,OAAO,SACT,OAAA,GAAA,4BAAA,aAAkB,IAAI,MAAM,OAAO,UAAU,oBAAoB,GAAG,MAAM;CAG5E,OAAO,OAAO;AAChB;;;;;;AAOA,SAAgB,oBAAuB,KAAuD;CAC5F,MAAM,OAAO,OAAO,KAAK,GAAgB;CAIzC,IAFiB,KAAK,WAAW,KAAK,KAAK,OAAO,UAEpC;EACZ,MAAM,EAAE,WAAW;EACnB,IAAI,CAAC,OAAO,SAAS,QAAA,GAAA,6BAAA,YAAkB,QAAQ,CAAC,WAAW,QAAQ,CAAC;EACpE,OAAA,GAAA,4BAAA,aAAkB,IAAI,MAAM,OAAO,MAAM,GAAG,MAAM;CACpD;CAGA,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,WAAW,KAA+B;CACxD,OAAO,eAAe;AACxB"}

package/dist/_helpers.d.ts

@@ -1,5 +1,6 @@
 import { CloudMethodOutput } from './cloud';
 import { ClientDatabaseOutput, CloudDatabaseOutput } from './database';
+import { UniError } from './_types';
 /**
  * 解析云对象方法调用的输出结果
  *
@@ -16,3 +17,13 @@ export declare function parseCloudMethodOutput<O>(output: CloudMethodOutput<O>,
  * @returns 处理后的结果
  */
 export declare function parseDatabaseOutput<T>(res: ClientDatabaseOutput<T> | CloudDatabaseOutput<T>): T | Omit<T & import('./_types').UniErrorData, "errCode" | "errMsg">;
+/**
+ * 检查给定的未知值是否为 UniError 类型。
+ *
+ * 该函数作为 TypeScript 的类型守卫（Type Guard），在运行时验证传入的对象是否为 Error 的实例，
+ * 并在类型系统中将未知类型（unknown）收窄为 UniError 类型。
+ *
+ * @param {unknown} err - 需要检查的未知值。
+ * @returns {boolean} 如果传入的值是 Error 的实例，则返回 true，否则返回 false。
+ */
+export declare function isUniError(err: unknown): err is UniError;

package/dist/_helpers.mjs

@@ -28,7 +28,19 @@ function parseDatabaseOutput(res) {
 	}
 	return res;
 }
+/**
+* 检查给定的未知值是否为 UniError 类型。
+*
+* 该函数作为 TypeScript 的类型守卫（Type Guard），在运行时验证传入的对象是否为 Error 的实例，
+* 并在类型系统中将未知类型（unknown）收窄为 UniError 类型。
+*
+* @param {unknown} err - 需要检查的未知值。
+* @returns {boolean} 如果传入的值是 Error 的实例，则返回 true，否则返回 false。
+*/
+function isUniError(err) {
+	return err instanceof Error;
+}
 //#endregion
-export { parseDatabaseOutput as n, parseCloudMethodOutput as t };
+export { parseCloudMethodOutput as n, parseDatabaseOutput as r, isUniError as t };
 
 //# sourceMappingURL=_helpers.mjs.map

package/dist/_helpers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_helpers.mjs","names":[],"sources":["../src/_helpers.ts"],"sourcesContent":["import { errorAssign } from '@cloudcome/utils-core/error';\nimport { objectOmit } from '@cloudcome/utils-core/object';\nimport type { CloudMethodOutput } from './cloud';\nimport type { ClientDatabaseOutput, CloudDatabaseOutput } from './database';\n\n/**\n * 解析云对象方法调用的输出结果\n *\n * @template O - 云对象方法返回数据的类型\n * @param output - 云对象方法调用的输出结果\n * @param fallbackErrorMessage - 当输出中没有错误信息时使用的默认错误消息\n * @returns 云对象方法返回成功时的数据部分\n * @throws 当云对象方法调用失败时，抛出包含错误信息的异常\n */\nexport function parseCloudMethodOutput<O>(output: CloudMethodOutput<O>, fallbackErrorMessage = ''): O {\n  if (output.errCode) {\n    throw errorAssign(new Error(output.errMsg || fallbackErrorMessage), output);\n  }\n\n  return output.data;\n}\n\n/**\n * 解析数据库执行结果\n * @param res 客户端、云端响应结果\n * @returns 处理后的结果\n */\nexport function parseDatabaseOutput<T>(res: ClientDatabaseOutput<T> | CloudDatabaseOutput<T>) {\n  const keys = Object.keys(res as AnyObject);\n  // 客户端 { result: {errCode: 0, errMsg: 'ok'} & 数据 }\n  const isClient = keys.length === 1 && keys[0] === 'result';\n\n  if (isClient) {\n    const { result } = res as ClientDatabaseOutput<T>;\n    if (!result.errCode) return objectOmit(result, ['errCode', 'errMsg']);\n    throw errorAssign(new Error(result.errMsg), result);\n  }\n\n  // 云端 数据\n  return res as T;\n}\n"],"mappings":";;;;;;;;;;;;AAcA,SAAgB,uBAA0B,QAA8B,uBAAuB,IAAO;CACpG,IAAI,OAAO,SACT,MAAM,YAAY,IAAI,MAAM,OAAO,UAAU,oBAAoB,GAAG,MAAM;CAG5E,OAAO,OAAO;AAChB;;;;;;AAOA,SAAgB,oBAAuB,KAAuD;CAC5F,MAAM,OAAO,OAAO,KAAK,GAAgB;CAIzC,IAFiB,KAAK,WAAW,KAAK,KAAK,OAAO,UAEpC;EACZ,MAAM,EAAE,WAAW;EACnB,IAAI,CAAC,OAAO,SAAS,OAAO,WAAW,QAAQ,CAAC,WAAW,QAAQ,CAAC;EACpE,MAAM,YAAY,IAAI,MAAM,OAAO,MAAM,GAAG,MAAM;CACpD;CAGA,OAAO;AACT"}
+{"version":3,"file":"_helpers.mjs","names":[],"sources":["../src/_helpers.ts"],"sourcesContent":["import { errorAssign } from '@cloudcome/utils-core/error';\nimport { objectOmit } from '@cloudcome/utils-core/object';\nimport type { CloudMethodOutput } from './cloud';\nimport type { ClientDatabaseOutput, CloudDatabaseOutput } from './database';\nimport type { UniError } from './_types';\n\n/**\n * 解析云对象方法调用的输出结果\n *\n * @template O - 云对象方法返回数据的类型\n * @param output - 云对象方法调用的输出结果\n * @param fallbackErrorMessage - 当输出中没有错误信息时使用的默认错误消息\n * @returns 云对象方法返回成功时的数据部分\n * @throws 当云对象方法调用失败时，抛出包含错误信息的异常\n */\nexport function parseCloudMethodOutput<O>(output: CloudMethodOutput<O>, fallbackErrorMessage = ''): O {\n  if (output.errCode) {\n    throw errorAssign(new Error(output.errMsg || fallbackErrorMessage), output);\n  }\n\n  return output.data;\n}\n\n/**\n * 解析数据库执行结果\n * @param res 客户端、云端响应结果\n * @returns 处理后的结果\n */\nexport function parseDatabaseOutput<T>(res: ClientDatabaseOutput<T> | CloudDatabaseOutput<T>) {\n  const keys = Object.keys(res as AnyObject);\n  // 客户端 { result: {errCode: 0, errMsg: 'ok'} & 数据 }\n  const isClient = keys.length === 1 && keys[0] === 'result';\n\n  if (isClient) {\n    const { result } = res as ClientDatabaseOutput<T>;\n    if (!result.errCode) return objectOmit(result, ['errCode', 'errMsg']);\n    throw errorAssign(new Error(result.errMsg), result);\n  }\n\n  // 云端 数据\n  return res as T;\n}\n\n/**\n * 检查给定的未知值是否为 UniError 类型。\n *\n * 该函数作为 TypeScript 的类型守卫（Type Guard），在运行时验证传入的对象是否为 Error 的实例，\n * 并在类型系统中将未知类型（unknown）收窄为 UniError 类型。\n *\n * @param {unknown} err - 需要检查的未知值。\n * @returns {boolean} 如果传入的值是 Error 的实例，则返回 true，否则返回 false。\n */\nexport function isUniError(err: unknown): err is UniError {\n  return err instanceof Error;\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,uBAA0B,QAA8B,uBAAuB,IAAO;CACpG,IAAI,OAAO,SACT,MAAM,YAAY,IAAI,MAAM,OAAO,UAAU,oBAAoB,GAAG,MAAM;CAG5E,OAAO,OAAO;AAChB;;;;;;AAOA,SAAgB,oBAAuB,KAAuD;CAC5F,MAAM,OAAO,OAAO,KAAK,GAAgB;CAIzC,IAFiB,KAAK,WAAW,KAAK,KAAK,OAAO,UAEpC;EACZ,MAAM,EAAE,WAAW;EACnB,IAAI,CAAC,OAAO,SAAS,OAAO,WAAW,QAAQ,CAAC,WAAW,QAAQ,CAAC;EACpE,MAAM,YAAY,IAAI,MAAM,OAAO,MAAM,GAAG,MAAM;CACpD;CAGA,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,WAAW,KAA+B;CACxD,OAAO,eAAe;AACxB"}

package/dist/client.cjs

@@ -426,6 +426,7 @@ async function querySelectorRects(instance, selector) {
 }
 //#endregion
 exports.importCloudObject = importCloudObject;
+exports.isUniError = require__helpers.isUniError;
 exports.parseCloudMethodOutput = require__helpers.parseCloudMethodOutput;
 exports.querySelectorRects = querySelectorRects;
 exports.uniAlert = uniAlert;

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-export { parseCloudMethodOutput } from './_helpers';
+export { parseCloudMethodOutput, isUniError } from './_helpers';
 export type { UniError } from './_types';
 export * from './client/app';
 export * from './client/async';

package/dist/client.mjs

@@ -1,4 +1,4 @@
-import { t as parseCloudMethodOutput } from "./_helpers.mjs";
+import { n as parseCloudMethodOutput, t as isUniError } from "./_helpers.mjs";
 import { errorAssign } from "@cloudcome/utils-core/error";
 import { _runLifeHook } from "@cloudcome/utils-vue/shared";
 import { onHide, onLoad, onPageHide, onPageShow, onShow, onUnload } from "@dcloudio/uni-app";
@@ -424,6 +424,6 @@ async function querySelectorRects(instance, selector) {
 	});
 }
 //#endregion
-export { importCloudObject, parseCloudMethodOutput, querySelectorRects, uniAlert, uniCallback, uniConfirm, uniLoading, uniPromise, uniPrompt, uniSubscribeNotice, uniToast, useAppShow, useAppUpdate, useDatabase, usePageLoad, usePageQuery, usePageShow };
+export { importCloudObject, isUniError, parseCloudMethodOutput, querySelectorRects, uniAlert, uniCallback, uniConfirm, uniLoading, uniPromise, uniPrompt, uniSubscribeNotice, uniToast, useAppShow, useAppUpdate, useDatabase, usePageLoad, usePageQuery, usePageShow };
 
 //# sourceMappingURL=client.mjs.map

package/dist/cloud.cjs

@@ -233,6 +233,7 @@ async function request(options) {
 //#endregion
 exports.buildCloudMethodCreator = buildCloudMethodCreator;
 exports.createCloudObjectError = createCloudObjectError;
+exports.isUniError = require__helpers.isUniError;
 exports.parseCloudMethodOutput = require__helpers.parseCloudMethodOutput;
 exports.parseCloudModuleOutput = parseCloudModuleOutput;
 exports.request = request;

package/dist/cloud.d.ts

@@ -1,4 +1,4 @@
-export { parseCloudMethodOutput } from './_helpers';
+export { parseCloudMethodOutput, isUniError } from './_helpers';
 export type { UniError } from './_types';
 export * from './cloud/error';
 export * from './cloud/method';

package/dist/cloud.mjs

@@ -1,4 +1,4 @@
-import { t as parseCloudMethodOutput } from "./_helpers.mjs";
+import { n as parseCloudMethodOutput, t as isUniError } from "./_helpers.mjs";
 import { errorAssign, errorNormalize } from "@cloudcome/utils-core/error";
 import { objectDefaults, objectOmit } from "@cloudcome/utils-core/object";
 import { isFunction } from "@cloudcome/utils-core/type";
@@ -230,6 +230,6 @@ async function request(options) {
 	});
 }
 //#endregion
-export { buildCloudMethodCreator, createCloudObjectError, parseCloudMethodOutput, parseCloudModuleOutput, request, respondCloudMethod };
+export { buildCloudMethodCreator, createCloudObjectError, isUniError, parseCloudMethodOutput, parseCloudModuleOutput, request, respondCloudMethod };
 
 //# sourceMappingURL=cloud.mjs.map

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

@@ -1,5 +1,5 @@
-import { AnyObject, MergeIntersection } from '@cloudcome/utils-core/types';
 import { UniError } from '../_types';
+import { AnyObject, MergeIntersection } from '@cloudcome/utils-core/types';
 import { DbQueryCommand } from './_command.class';
 import { DbCreate, DbForeign, DbOrder, DbQuery, DbRelation, DbSelect, DbUpdate, DbWhere } from './types';
 export type DbOptions = {
@@ -17,10 +17,10 @@ export type DbOptions = {
     _mockDatabase?: any;
     /**
      * 自定义错误处理函数
-     * @param error 数据库错误对象
-     * @returns 处理后的数据库错误对象
+     * @param error unknown 数据库异常对象
+     * @returns 自定义错误对象
      */
-    parseError?: (error: UniError) => UniError;
+    parseError?: (error: unknown) => UniError;
 };
 export type DbLookupOptions<RL extends DbRelation, D1, FD1, AS, US extends boolean | undefined | void = undefined> = {
     /**
@@ -156,6 +156,18 @@ export declare class Db<D1, S1 extends DbSelect<D1> = {}, D2 extends AnyObject =
     private _lookupAs;
     private _endAggregate;
     private _endHost;
+    /**
+     * 将 uniCloud 数据库原始错误包装为 DbError
+     * @param err - 原始错误对象，来自 uniCloud DB 操作（Error 实例，含 errMsg、errCode 属性）
+     * @returns DbError 实例
+     */
+    private _parseDbError;
+    /**
+     * 统一处理 DB 操作抛出的错误
+     * - uniCloud 数据库错误（含 errMsg）→ 包装为 DbError → 经 parseError 回调后抛出
+     * - 非数据库错误（如网络中断）→ 原样抛出
+     */
+    private _handleDbError;
     /**
      * 执行查询操作
      * @returns 查询结果

package/dist/database/error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 数据库底层异常类
+ * 当 uniCloud 数据库操作抛出错误时，统一包装为该异常
+ */
+export declare class DbError extends Error {
+    /** 原始错误码，如 'InternalServerError' */
+    errCode: string | number;
+    /** MongoDB 错误码，如 'E11000'。不匹配则为空字符串 */
+    dbCode: string;
+    constructor(message: string, extra: {
+        errCode: string | number;
+        dbCode: string;
+    });
+}
+/**
+ * 判断错误是否为数据库底层错误
+ * @param err - 任意错误对象
+ * @returns 是否为 DbError
+ */
+export declare function isDbError(err: unknown): err is DbError;
+/**
+ * 从 MongoDB 错误消息中提取错误码
+ * @param errMsg - 错误消息字符串，如 'E11000 duplicate key error...'
+ * @returns MongoDB 错误码，如 'E11000'
+ */
+export declare function extractMongoCode(errMsg: string): string;

package/dist/database/proxy.d.ts

@@ -1,13 +1,13 @@
-import { UniError } from '../_types';
 import { Db } from './_db.class';
 import { DbSelect } from './types';
+import { UniError } from '../_types';
 export type DbProxyOptions = {
     /**
      * 自定义错误处理函数
-     * @param error 数据库错误对象
-     * @returns 处理后的数据库错误对象
+     * @param error unknown 数据库异常对象
+     * @returns 自定义错误对象
      */
-    parseError?: (error: UniError) => UniError;
+    parseError?: (error: unknown) => UniError;
 };
 /**
  * 创建一个数据库代理对象，用于延迟实例化数据库操作类

package/dist/database.cjs

@@ -204,6 +204,41 @@ async function dbEach(table, where, iterator, maxCount = Number.MAX_SAFE_INTEGER
 	}
 }
 //#endregion
+//#region src/database/error.ts
+/**
+* 数据库底层异常类
+* 当 uniCloud 数据库操作抛出错误时，统一包装为该异常
+*/
+var DbError = class extends Error {
+	/** 原始错误码，如 'InternalServerError' */
+	errCode;
+	/** MongoDB 错误码，如 'E11000'。不匹配则为空字符串 */
+	dbCode;
+	constructor(message, extra) {
+		super(message);
+		this.name = "DbError";
+		this.errCode = extra.errCode;
+		this.dbCode = extra.dbCode;
+	}
+};
+/**
+* 判断错误是否为数据库底层错误
+* @param err - 任意错误对象
+* @returns 是否为 DbError
+*/
+function isDbError(err) {
+	return err instanceof DbError;
+}
+/**
+* 从 MongoDB 错误消息中提取错误码
+* @param errMsg - 错误消息字符串，如 'E11000 duplicate key error...'
+* @returns MongoDB 错误码，如 'E11000'
+*/
+function extractMongoCode(errMsg) {
+	const m = errMsg.match(/^E\d+/);
+	return m ? m[0] : "";
+}
+//#endregion
 //#region src/database/paging.ts
 /**
 * 数据库分页查询函数
@@ -464,6 +499,32 @@ var Db = class Db {
 		return hostRef;
 	}
 	/**
+	* 将 uniCloud 数据库原始错误包装为 DbError
+	* @param err - 原始错误对象，来自 uniCloud DB 操作（Error 实例，含 errMsg、errCode 属性）
+	* @returns DbError 实例
+	*/
+	_parseDbError(err) {
+		const errCode = err.errCode || "";
+		const message = err.errMsg || err.message;
+		const dbCode = extractMongoCode(err.errMsg || err.message);
+		if (dbCode) return new DbError(message, {
+			errCode,
+			dbCode
+		});
+		else return err;
+	}
+	/**
+	* 统一处理 DB 操作抛出的错误
+	* - uniCloud 数据库错误（含 errMsg）→ 包装为 DbError → 经 parseError 回调后抛出
+	* - 非数据库错误（如网络中断）→ 原样抛出
+	*/
+	_handleDbError(err) {
+		if (require__helpers.isUniError(err)) {
+			const dbErr = this._parseDbError(err);
+			throw this._options.parseError?.(dbErr) || dbErr;
+		} else throw this._options.parseError?.(err) || err;
+	}
+	/**
 	* 执行查询操作
 	* @returns 查询结果
 	*/
@@ -482,8 +543,7 @@ var Db = class Db {
 			const { data } = require__helpers.parseDatabaseOutput(res);
 			return data;
 		} catch (err) {
-			const dbErr = err;
-			throw this._options.parseError?.(dbErr) || dbErr;
+			this._handleDbError(err);
 		}
 	}
 	/**
@@ -525,8 +585,7 @@ var Db = class Db {
 			const { total } = require__helpers.parseDatabaseOutput(await hostRef.count());
 			return total;
 		} catch (err) {
-			const dbErr = err;
-			throw this._options.parseError?.(dbErr) || dbErr;
+			this._handleDbError(err);
 		}
 	}
 	/**
@@ -547,8 +606,7 @@ var Db = class Db {
 			const { id } = require__helpers.parseDatabaseOutput(await hostRef.add(data));
 			return id;
 		} catch (err) {
-			const dbErr = err;
-			throw this._options.parseError?.(dbErr) || dbErr;
+			this._handleDbError(err);
 		}
 	}
 	/**
@@ -570,8 +628,7 @@ var Db = class Db {
 			const { updated } = require__helpers.parseDatabaseOutput(await hostRef.update((0, _cloudcome_utils_core_object.objectOmit)(_mapCommandRaw(data), ["_id"])));
 			return updated;
 		} catch (err) {
-			const dbErr = err;
-			throw this._options.parseError?.(dbErr) || dbErr;
+			this._handleDbError(err);
 		}
 	}
 	/**
@@ -592,8 +649,7 @@ var Db = class Db {
 			const { deleted } = require__helpers.parseDatabaseOutput(await hostRef.remove());
 			return deleted;
 		} catch (err) {
-			const dbErr = err;
-			throw this._options.parseError?.(dbErr) || dbErr;
+			this._handleDbError(err);
 		}
 	}
 };
@@ -726,6 +782,7 @@ async function dbUnique(db, options) {
 	};
 }
 //#endregion
+exports.DbError = DbError;
 exports.dbEach = dbEach;
 exports.dbMutate = dbMutate;
 exports.dbPaging = dbPaging;
@@ -734,6 +791,9 @@ exports.dbQuery = dbQuery;
 exports.dbTransaction = dbTransaction;
 exports.dbUnique = dbUnique;
 exports.dbUpsert = dbUpsert;
+exports.extractMongoCode = extractMongoCode;
+exports.isDbError = isDbError;
+exports.isUniError = require__helpers.isUniError;
 exports.parseDatabaseOutput = require__helpers.parseDatabaseOutput;
 
 //# sourceMappingURL=database.cjs.map