mm_mongodb 1.4.3 → 1.4.5

package/index.js

@@ -1,15 +1,23 @@
 /**
- * @fileOverview mongoDB帮助类函数
+ * @fileOverview MongoDB帮助类函数
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.2.1
  */
-require('mm_expand');
+const eventEmitter = require('events');
+require('mm_logs');
 const MongoClient = require('mongodb').MongoClient;
 
+/**
+ * 确保全局$对象存在
+ */
+if (!global.$) {
+	global.$ = {};
+}
+
 /**
  * @description MongoDB帮助类
  */
-class MongoDB {
+class MongoDB extends eventEmitter {
 	/**
 	 * @description 创建MongoDB帮助类函数 (构造函数)
 	 * @param {String} scope 作用域
@@ -17,18 +25,15 @@ class MongoDB {
 	 * @constructor
 	 */
 	constructor(scope, dir, config) {
+		super();
 		// 作用域
-		this.scope;
-		if (scope) {
-			this.scope = scope;
-		} else {
-			this.scope = $.val.scope + '';
-		}
+		this.scope = scope || ($.val && $.val.scope ? String($.val.scope) : 'default');
 		// 当前目录
-		this.dir = __dirname;
-		if (dir) {
-			this.dir = dir;
-		}
+		this.dir = dir || __dirname;
+
+		// 从环境变量加载配置
+		const envConfig = this._loadEnvConfig();
+
 		this.config = Object.assign({
 			// 服务器地址
 			host: "localhost",
@@ -40,25 +45,36 @@ class MongoDB {
 			user: "admin",
 			// 密码
 			password: "",
-			// 附加选项
+			// 连接选项
 			options: {
-				// 使用新的url分析器
-				useNewUrlParser: true,
-				// 自动重连接
-				// auto_reconnect: true,
-				// 使用统一拓扑
-				useUnifiedTopology: true,
-				// useCreateIndex: true,
-				// 连接池数
-				// poolSize: 10
+				// 移除已废弃的选项
+				// 使用MongoDB驱动推荐的配置
+				// 连接池配置
+				minPoolSize: 5,
+				maxPoolSize: 20,
+				// 连接超时时间
+				connectTimeoutMS: 10000,
+				// 服务器选择超时
+				serverSelectionTimeoutMS: 5000,
+				// 重试策略
+				retryWrites: true
+			},
+			// 重试配置
+			retry: {
+				maxAttempts: 3,
+				delayMS: 1000
 			}
-		}, config);
+		}, envConfig, config);
+
+		// 验证配置
+		this._validateConfig();
+
 		// 连接地址
-		this.url;
+		this.url = null;
 		// 数据库连接器
-		this.conn;
+		this.conn = null;
 		// 操作的数据库
-		this.db;
+		this.db = null;
 		// 表名
 		this.table = "cache";
 		/**
@@ -69,6 +85,74 @@ class MongoDB {
 		 * 每页显示条数
 		 */
 		this.size = 0;
+		// 连接状态
+		this.connected = false;
+	}
+
+	/**
+	 * @private
+	 * @description 从环境变量加载配置
+	 * @return {Object} 配置对象
+	 */
+	_loadEnvConfig() {
+		const envConfig = {};
+
+		if (process.env.MONGODB_HOST) envConfig.host = process.env.MONGODB_HOST;
+		if (process.env.MONGODB_PORT) envConfig.port = parseInt(process.env.MONGODB_PORT, 10);
+		if (process.env.MONGODB_DATABASE) envConfig.database = process.env.MONGODB_DATABASE;
+		if (process.env.MONGODB_USER) envConfig.user = process.env.MONGODB_USER;
+		if (process.env.MONGODB_PASSWORD) envConfig.password = process.env.MONGODB_PASSWORD;
+
+		return envConfig;
+	}
+
+	/**
+	 * @private
+	 * @description 验证配置有效性
+	 * @throws {Error} 配置无效时抛出错误
+	 */
+	_validateConfig() {
+		if (!this.config.host || typeof this.config.host !== 'string') {
+			throw new Error('MongoDB配置无效：host必须是有效的字符串');
+		}
+
+		if (!Number.isInteger(this.config.port) || this.config.port < 1 || this.config.port > 65535) {
+			throw new Error('MongoDB配置无效：port必须是1-65535之间的整数');
+		}
+
+		if (!this.config.database || typeof this.config.database !== 'string') {
+			throw new Error('MongoDB配置无效：database必须是有效的字符串');
+		}
+	}
+
+	/**
+	 * @private
+	 * @description 执行带重试的操作
+	 * @param {Function} operation 要执行的操作
+	 * @param {String} operationName 操作名称
+	 * @return {Promise} 操作结果
+	 */
+	async _withRetry(operation, operationName) {
+		const maxAttempts = this.config.retry?.maxAttempts || 3;
+		const delayMS = this.config.retry?.delayMS || 1000;
+		let lastError;
+
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			try {
+				return await operation();
+			} catch (error) {
+				lastError = error;
+				$.log.error(`[MongoDB] ${operationName} 第${attempt}次尝试失败:`, error.message);
+
+				// 如果不是最后一次尝试，则等待后重试
+				if (attempt < maxAttempts) {
+					await new Promise(resolve => setTimeout(resolve, delayMS));
+				}
+			}
+		}
+
+		// 所有重试都失败，抛出最后一个错误
+		throw lastError;
 	}
 }
 
@@ -76,49 +160,79 @@ class MongoDB {
  * @description 设置配置
  * @param {Object|String} cg 配置对象或配置路径
  */
-MongoDB.prototype.setConfig = function(cg) {
+MongoDB.prototype.setConfig = function (cg) {
 	var obj;
-	if (typeof(cg) === "string") {
-		obj = cg.loadJson(this.dir);
-	} else {
+	if (typeof (cg) === "string") {
+		obj = cg.loadJson ? cg.loadJson(this.dir) : null;
+	} else if (cg) {
 		obj = cg;
 	}
-	$.push(this.config, obj);
+	if (obj) {
+		$.push(this.config, obj);
+		// 设置新配置后重新验证
+		this._validateConfig();
+	}
 };
 
 /**
  * @description 设置Url
  */
-MongoDB.prototype.setUrl = function() {
+MongoDB.prototype.setUrl = function () {
 	var url = "mongodb://";
 	if (this.config.password) {
-		url += this.config.user + ':' + this.config.password + '@';
+		url += encodeURIComponent(this.config.user) + ':' + encodeURIComponent(this.config.password) + '@';
 	}
 	url += this.config.host + ":" + this.config.port + "/";
 	this.url = url;
 };
 
 /**
- * @description 连接mongoDB数据库
- * @return {Boolean} 连接成功返回true, 失败返回false
+ * @description 连接MongoDB数据库
+ * @return {Promise<Boolean>} 连接成功返回true, 失败抛出错误
  */
-MongoDB.prototype.open = async function() {
+MongoDB.prototype.open = async function () {
 	if (!this.url) {
 		this.setUrl();
 	}
 	if (!this.conn) {
-		this.conn = await MongoClient.connect(this.url, this.config.options);
-		this.db = this.conn.db(this.config.database);
+		return await this._withRetry(async () => {
+			try {
+				this.conn = await MongoClient.connect(this.url, this.config.options);
+				this.db = this.conn.db(this.config.database);
+				this.connected = true;
+
+				// 设置连接事件监听
+				this.conn.on('error', (err) => {
+					$.log.error('[MongoDB] 连接错误:', err);
+					this.connected = false;
+				});
+
+				this.conn.on('close', () => {
+					$.log.warn('[MongoDB] 连接已关闭');
+					this.connected = false;
+				});
+
+				$.log.info(`[MongoDB] 成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`);
+				return true;
+			} catch (error) {
+				$.log.error('[MongoDB] MongoDB连接失败:', error);
+				throw error;
+			}
+		}, '数据库连接');
 	}
-	return this.conn == true;
+	return true;
 };
 
 /**
  * 关闭数据库连接
  */
-MongoDB.prototype.close = function() {
+MongoDB.prototype.close = async function () {
 	if (this.conn) {
-		this.conn.close();
+		$.log.info(`[MongoDB] 关闭连接`);
+		await this.conn.close().catch(err => $.log.error('[MongoDB] 关闭MongoDB连接时出错:', err));
+		this.conn = null;
+		this.db = null;
+		this.connected = false;
 	}
 };
 
@@ -127,7 +241,7 @@ MongoDB.prototype.close = function() {
  * @param {Object} table 表名
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addTable = function(table) {
+MongoDB.prototype.addTable = function (table) {
 	if (table) {
 		this.table = table;
 	} else {
@@ -136,13 +250,161 @@ MongoDB.prototype.addTable = function(table) {
 	return this.db.createCollection(table);
 };
 
+/**
+ * @description 创建TTL索引
+ * @param {String} table 表名
+ * @param {String} field 过期字段名
+ * @param {Number} expireAfterSeconds 过期时间(秒)
+ * @return {Promise<Object>} 执行结果
+ */
+MongoDB.prototype.createTTLIndex = async function (table, field, expireAfterSeconds) {
+	if (!table) table = this.table;
+	return await this.db.collection(table).createIndex(
+		{ [field]: 1 },
+		{ expireAfterSeconds: expireAfterSeconds || 0 }
+	);
+};
+
+/**
+ * @description 创建普通索引
+ * @param {String} table 表名
+ * @param {Object} keys 索引字段对象
+ * @param {Object} options 索引选项
+ * @return {Promise<Object>} 执行结果
+ */
+/**
+ * @description 创建索引
+ * @param {Object} keys 索引键配置 {field: 1或-1}
+ * @param {Object} options 索引选项
+ * @returns {Promise<Object>} 创建索引的结果
+ */
+MongoDB.prototype.createIndex = async function (keys, options = {}) {
+	try {
+		if (!this.db || !this.table) {
+			throw new Error('数据库未连接或未指定表名');
+		}
+
+		$.log.info(`[MongoDB] 创建索引: ${this.table}, keys: ${JSON.stringify(keys)}, options: ${JSON.stringify(options)}`);
+
+		return await this.db.collection(this.table).createIndex(keys, options);
+	} catch (error) {
+		$.log.error(`[MongoDB] 创建索引失败: ${error.message}`);
+		throw error;
+	}
+};
+
+/**
+ * @description 创建TTL索引（数据自动过期）
+ * @param {Object} keys 索引键配置 {field: 1}
+ * @param {Number} expireAfterSeconds 过期时间（秒）
+ * @returns {Promise<Object>} 创建索引的结果
+ */
+MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
+	try {
+		if (!this.db || !this.table) {
+			throw new Error('数据库未连接或未指定表名');
+		}
+
+		const options = {
+			background: true,
+			expireAfterSeconds: expireAfterSeconds
+		};
+
+		$.log.info(`[MongoDB] 创建TTL索引: ${this.table}, keys: ${JSON.stringify(keys)}, 过期时间: ${expireAfterSeconds}秒`);
+
+		return await this.db.collection(this.table).createIndex(keys, options);
+	} catch (error) {
+		$.log.error(`[MongoDB] 创建TTL索引失败: ${error.message}`);
+		throw error;
+	}
+};
+
+/**
+ * @description 获取集合的所有索引
+ * @returns {Promise<Array>} 索引信息数组
+ */
+MongoDB.prototype.getIndexes = async function () {
+	try {
+		if (!this.db || !this.table) {
+			throw new Error('数据库未连接或未指定表名');
+		}
+
+		$.log.info(`[MongoDB] 获取索引: ${this.table}`);
+		return await this.db.collection(this.table).indexes();
+	} catch (error) {
+		$.log.error(`[MongoDB] 获取索引失败: ${error.message}`);
+		return [];
+	}
+};
+
+/**
+ * @description 删除指定索引
+ * @param {String} indexName 索引名称
+ * @returns {Promise<Boolean>} 是否删除成功
+ */
+MongoDB.prototype.dropIndex = async function (indexName) {
+	if (!this.conn || !this.db) {
+		throw new Error('数据库未连接');
+	}
+	if (!this.table) {
+		throw new Error('未指定表名');
+	}
+	if (!indexName) {
+		throw new Error('索引名称不能为空');
+	}
+	try {
+		$.log.info(`[MongoDB] 删除索引: ${this.table}, 索引名: ${indexName}`);
+		await this.db.collection(this.table).dropIndex(indexName);
+		return true;
+	} catch (error) {
+		$.log.error(`[MongoDB] 删除索引失败: ${error.message}`);
+		throw error;
+	}
+};
+
+/**
+ * @description 删除集合（表）
+ * @returns {Promise<Boolean>} 是否删除成功
+ */
+MongoDB.prototype.dropTable = async function () {
+	if (!this.conn || !this.db) {
+		throw new Error('数据库未连接');
+	}
+	if (!this.table) {
+		throw new Error('未指定表名');
+	}
+	try {
+		$.log.info(`[MongoDB] 删除集合: ${this.table}`);
+		await this.db.collection(this.table).drop();
+		return true;
+	} catch (error) {
+		$.log.error(`[MongoDB] 删除集合失败: ${error.message}`);
+		throw error;
+	}
+};
+
 /**
  * @description 增加一条缓存
  * @param {Object} obj 对象
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addObj = function(obj) {
-	return this.db.collection(this.table).insertOne(obj);
+MongoDB.prototype.addObj = async function(obj) {
+	try {
+		// 触发前置事件
+		this.emit('beforeInsert', { table: this.table, data: obj });
+		
+		// 执行插入操作
+		const result = await this.db.collection(this.table).insertOne(obj);
+		
+		// 触发后置事件
+		this.emit('afterInsert', { table: this.table, data: obj, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('insertError', { table: this.table, data: obj, error });
+		throw error;
+	}
 };
 
 /**
@@ -150,8 +412,23 @@ MongoDB.prototype.addObj = function(obj) {
  * @param {Array} list 对象数组
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addList = function(list) {
-	return this.db.collection(this.table).insertMany(list);
+MongoDB.prototype.addList = async function(list) {
+	try {
+		// 触发前置事件
+		this.emit('beforeInsertMany', { table: this.table, data: list });
+		
+		// 执行插入操作
+		const result = await this.db.collection(this.table).insertMany(list);
+		
+		// 触发后置事件
+		this.emit('afterInsertMany', { table: this.table, data: list, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('insertManyError', { table: this.table, data: list, error });
+		throw error;
+	}
 };
 
 /**
@@ -159,43 +436,185 @@ MongoDB.prototype.addList = function(list) {
  * @param {Object} query 查询条件对象
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.del = function(query) {
-	return this.db.collection(this.table).remove(query);
+MongoDB.prototype.del = async function(query) {
+	try {
+		// 触发前置事件
+		this.emit('beforeDelete', { table: this.table, query });
+		
+		// 执行删除操作
+		const result = await this.db.collection(this.table).deleteMany(query);
+		
+		// 触发后置事件
+		this.emit('afterDelete', { table: this.table, query, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('deleteError', { table: this.table, query, error });
+		throw error;
+	}
 };
 
 /**
  * @description 修改缓存
  * @param {Object} query 查询条件对象
  * @param {Object} body 修改对象
+ * @param {Object} options 附加选项
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.set = function(query, body) {
-	return this.db.collection(this.table).update(query, body);
+MongoDB.prototype.set = async function(query, body, options = {}) {
+	try {
+		// 默认使用$set操作符进行部分更新
+		if (!body.$set && !body.$inc && !body.$push) {
+			body = { $set: body };
+		}
+		// 默认更新多条
+		const updateOptions = Object.assign({ multi: true }, options);
+		
+		// 触发前置事件
+		this.emit('beforeUpdate', { table: this.table, query, update: body, options: updateOptions });
+		
+		// 执行更新操作
+		const result = await this.db.collection(this.table).updateMany(query, body, updateOptions);
+		
+		// 触发后置事件
+		this.emit('afterUpdate', { table: this.table, query, update: body, options: updateOptions, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('updateError', { table: this.table, query, update: body, options, error });
+		throw error;
+	}
 };
 
 /**
  * @description 查询缓存
  * @param {Object} query 查询条件对象
- * @return {Promise|Array} 执行结果
+ * @param {Object} options 查询选项
+ * @return {Promise|Array} 查询结果数组
  */
-MongoDB.prototype.get = function(query) {
-	if (this.page !== 0 && this.size !== 0) {
-		return this.db.collection(this.table).find(query).limit(this.size).skip((this.page - 1) * this
-			.size).toArray();
-	} else {
-		return this.db.collection(this.table).find(query).toArray();
+MongoDB.prototype.find = async function (query, options = {}) {
+	try {
+		// 安全处理查询条件，避免注入
+		const safeQuery = this._sanitizeQuery(query);
+		const cursor = this.db.collection(this.table).find(safeQuery, options);
+		return await cursor.toArray();
+	} catch (error) {
+		$.log.error('[MongoDB] 查询失败:', error);
+		return [];
 	}
 };
 
 /**
- * @module 导出MongoDB帮助类
+ * @description 查询单条数据
+ * @param {Object} query 查询条件对象
+ * @param {Object} options 查询选项
+ * @return {Promise<Object|null>} 查询结果
  */
-exports.MongoDB = MongoDB;
+MongoDB.prototype.findOne = async function (query, options = {}) {
+	try {
+		const safeQuery = this._sanitizeQuery(query);
+		return await this.db.collection(this.table).findOne(safeQuery, options);
+	} catch (error) {
+		$.log.error('[MongoDB] 查询单条数据失败:', error);
+		return null;
+	}
+};
+
+/**
+ * @description 计算文档数量
+ * @param {Object} query 查询条件对象
+ * @return {Promise<Number>} 文档数量
+ */
+MongoDB.prototype.count = async function (query = {}) {
+	try {
+		const safeQuery = this._sanitizeQuery(query);
+		return await this.db.collection(this.table).countDocuments(safeQuery);
+	} catch (error) {
+		$.log.error('[MongoDB] 计算文档数量失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * @private
+ * @description 清理查询条件，防止注入攻击
+ * @param {Object} query 查询条件
+ * @return {Object} 安全的查询条件
+ */
+MongoDB.prototype._sanitizeQuery = function (query) {
+	// 简单实现，可根据需要扩展更复杂的安全检查
+	const sanitized = {};
+
+	for (const [key, value] of Object.entries(query)) {
+		// 防止NoSQL注入，如 {$ne: null} 等操作符注入
+		if (key.startsWith('$') && typeof key === 'string' && !Array.isArray(value) && typeof value === 'object' && value !== null) {
+			$.log.warn('[MongoDB] 检测到可能的操作符注入尝试:', key);
+			continue;
+		}
+		sanitized[key] = value;
+	}
+
+	return sanitized;
+};
+
+/**
+ * @description 启动事务
+ * @return {Promise<Object>} 会话对象
+ */
+MongoDB.prototype.startTransaction = async function () {
+	try {
+		const session = this.conn.startSession();
+		session.startTransaction();
+		return session;
+	} catch (error) {
+		$.log.error('[MongoDB] 启动事务失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description 提交事务
+ * @param {Object} session 会话对象
+ * @return {Promise<void>}
+ */
+MongoDB.prototype.commitTransaction = async function (session) {
+	try {
+		await session.commitTransaction();
+		await session.endSession();
+	} catch (error) {
+		$.log.error('[MongoDB] 提交事务失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description 回滚事务
+ * @param {Object} session 会话对象
+ * @return {Promise<void>}
+ */
+MongoDB.prototype.rollbackTransaction = async function (session) {
+	try {
+		await session.abortTransaction();
+		await session.endSession();
+	} catch (error) {
+		$.log.error('[MongoDB] 回滚事务失败:', error);
+		throw error;
+	}
+};
 
+/**
+ * 导出MongoDB类
+ */
+exports.MongoDB = MongoDB;
 
 /**
- * @description mongoDB连接池
+ * 确保连接池对象存在
  */
+if (!$.pool) {
+	$.pool = {};
+}
 if (!$.pool.mongoDB) {
 	$.pool.mongoDB = {};
 }
@@ -204,11 +623,11 @@ if (!$.pool.mongoDB) {
  * @description MongoDB管理器，用于创建缓存
  * @param {String} scope 作用域
  * @param {String} dir 当前路径
- * @return {Object} 返回一个缓存类
+ * @return {Object} 返回一个MongoDB类实例
  */
 function mongoDB_admin(scope, dir) {
 	if (!scope) {
-		scope = $.val.scope
+		scope = ($.val && $.val.scope) || 'default';
 	}
 	var obj = $.pool.mongoDB[scope];
 	if (!obj) {
@@ -221,4 +640,4 @@ function mongoDB_admin(scope, dir) {
 /**
  * @module 导出MongoDB管理器
  */
-exports.mongoDB_admin = mongoDB_admin;
+exports.mongoDB_admin = mongoDB_admin;