mm_sql 1.3.8 → 1.4.0

package/index.js

@@ -1,6 +1,6 @@
 /**
  * @fileOverview SQL通用类
- * @author <a href="http://qww.elins.cn">邱文武</a>
+ * @author <a href="http://qww.elins.cn">qww</a>
  * @version 1.0
  */
 
@@ -17,7 +17,12 @@ class Sql {
 		 * 配置信息
 		 */
 		this.config = Object.assign({
-			db_type: 'mysql'
+            scope: 'sys',
+			db_type: 'mysql',
+            dir: '/db/',
+            host: 'localhost',
+            port: 3306,
+            database: ''
 		}, config || {});
 		
 		/**
@@ -49,12 +54,12 @@ Sql.prototype._createSqlAdapter = function () {
 	// 根据数据库类型选择不同的初始化方式
 	if (this.config.db_type === 'mysql') {
 		// 创建MySQL实例
-		const Mysql = adapter.Mysql;
-		this._adapter = new Mysql(this.config);
+		const admin = adapter.mysqlAdmin;
+		this._adapter = admin(this.config.scope, this.config);
 	} else if (this.config.db_type === 'sqlite') {
 		// SQLite应该有类似的结构
-		const Sqlite = adapter.Sqlite;
-		this._adapter = new Sqlite(this.config);
+        const admin = adapter.sqliteAdmin;
+		this._adapter = admin(this.config.scope, this.config);
 	} else {
 		// 其他数据库类型直接使用Sql类（如果存在）
 		const AdapterClass = adapter.Sql;
@@ -72,15 +77,32 @@ Sql.prototype._createSqlAdapter = function () {
  * @param {Array} params - 参数数组
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise} 查询结果
+ * @throws {TypeError} 当sql参数无效时
  */
 Sql.prototype.run = function (sql, params = [], timeout = null) {
-	// 支持两种调用方式：run(sql, params, timeout) 或 run({sql: '', params: []})
-	if (typeof sql === 'object') {
-		params = sql.params || [];
-		timeout = sql.timeout || null;
-		sql = sql.sql || '';
-	}
-	return this._adapter.run(sql, params, timeout);
+    // 参数校验
+    if (typeof sql !== 'string' && typeof sql !== 'object') {
+        throw new TypeError('sql must be string or object');
+    }
+    if (!Array.isArray(params)) {
+        throw new TypeError('params must be array');
+    }
+    if (timeout !== null && typeof timeout !== 'number') {
+        throw new TypeError('timeout must be number or null');
+    }
+    
+    try {
+        // 支持两种调用方式：run(sql, params, timeout) 或 run({sql: '', params: []})
+        if (typeof sql === 'object') {
+            params = sql.params || [];
+            timeout = sql.timeout || null;
+            sql = sql.sql || '';
+        }
+        return this._adapter.run(sql, params, timeout);
+    } catch (error) {
+        this.logger('error', 'SQL查询执行失败', error);
+        throw error;
+    }
 };
 
 /**
@@ -89,15 +111,32 @@ Sql.prototype.run = function (sql, params = [], timeout = null) {
  * @param {Array} params - 参数数组
  * @param {Number} timeout - 超时时间(毫秒)
  * @returns {Promise} 修改结果
+ * @throws {TypeError} 当sql参数无效时
  */
 Sql.prototype.exec = function (sql, params = [], timeout = null) {
-	// 支持两种调用方式：exec(sql, params, timeout) 或 exec({sql: '', params: []})
-	if (typeof sql === 'object') {
-		params = sql.params || [];
-		timeout = sql.timeout || null;
-		sql = sql.sql || '';
-	}
-	return this._adapter.exec(sql, params, timeout);
+    // 参数校验
+    if (typeof sql !== 'string' && typeof sql !== 'object') {
+        throw new TypeError('sql must be string or object');
+    }
+    if (!Array.isArray(params)) {
+        throw new TypeError('params must be array');
+    }
+    if (timeout !== null && typeof timeout !== 'number') {
+        throw new TypeError('timeout must be number or null');
+    }
+    
+    try {
+        // 支持两种调用方式：exec(sql, params, timeout) 或 exec({sql: '', params: []})
+        if (typeof sql === 'object') {
+            params = sql.params || [];
+            timeout = sql.timeout || null;
+            sql = sql.sql || '';
+        }
+        return this._adapter.exec(sql, params, timeout);
+    } catch (error) {
+        this.logger('error', 'SQL修改执行失败', error);
+        return 0;
+    }
 };
 
 /**
@@ -105,7 +144,12 @@ Sql.prototype.exec = function (sql, params = [], timeout = null) {
  * @returns {Promise} 连接结果
  */
 Sql.prototype.open = function () {
-	return this._adapter.open();
+    try {
+        return this._adapter.open();
+    } catch (error) {
+        this.logger('error', '数据库连接打开失败', error);
+        return null;
+    }
 };
 
 /**
@@ -113,57 +157,30 @@ Sql.prototype.open = function () {
  * @returns {Promise} 关闭结果
  */
 Sql.prototype.close = function () {
-	return this._adapter.close();
+    try {
+        return this._adapter.close();
+    } catch (error) {
+        this.logger('error', '数据库连接关闭失败', error);
+    }
 };
 
 /**
  * 设置配置
  * @param {Object} config - 配置对象
+ * @throws {TypeError} 当config参数无效时
  */
 Sql.prototype.setConfig = function (config) {
-	this.config = Object.assign(this.config, config);
-	this._init();
-};
-
-/**
- * 获取连接信息
- * @returns {Object} 连接信息
- */
-Sql.prototype.getConnectionInfo = function () {
-	// 确保返回包含必要字段的连接信息
-	return {
-		db_type: this.config.db_type,
-		host: this.config.host || 'localhost',
-		port: this.config.port || 3306,
-		database: this.config.database || ''
-	};
-};
-
-/**
- * 检查数据库连接状态
- * @returns {Boolean} 连接状态
- */
-Sql.prototype.isConnected = function () {
-	// 简单实现，返回true表示连接正常
-	return true;
-};
-
-/**
- * 获取标识符
- * @private
- * @param {String} name - 名称
- * @returns {String} 标识符
- */
-Sql.prototype._getIdentifier = function (name) {
-	const dbType = this.config.db_type;
-	switch (dbType) {
-		case 'mysql':
-			return `\`${name}\``;
-		case 'sqlite':
-			return `"${name}"`;
-		default:
-			return name;
-	}
+    // 参数校验
+    if (!config || typeof config !== 'object') {
+        throw new TypeError('config must be object');
+    }
+    
+    try {
+        this.config = Object.assign(this.config, config);
+        this._init();
+    } catch (error) {
+        this.logger('error', '配置设置失败', error);
+    }
 };
 
 /**
@@ -171,22 +188,36 @@ Sql.prototype._getIdentifier = function (name) {
  * @param {Object} paramDt - 参数对象
  * @param {Object} sqlDt - SQL模板对象
  * @returns {Object} 查询结果对象
+ * @throws {TypeError} 当参数对象无效时
  */
 Sql.prototype.tplQuery = function (paramDt, sqlDt) {
-	let sql = '';
-	
-	for (const key in paramDt) {
-		if (sqlDt[key]) {
-			// 替换占位符{0}为参数值
-			const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
-			sql += 'AND ' + sqlSegment + ' ';
-		}
-        else {
-            sql += 'AND `' + key + "` = '" + paramDt[key] + "'";
+    // 参数校验
+    if (!paramDt || typeof paramDt !== 'object') {
+        throw new TypeError('paramDt must be object');
+    }
+    if (!sqlDt || typeof sqlDt !== 'object') {
+        throw new TypeError('sqlDt must be object');
+    }
+    
+    try {
+        let sql = '';
+        
+        for (const key in paramDt) {
+            if (sqlDt[key]) {
+                // 替换占位符{0}为参数值
+                const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
+                sql += 'AND ' + sqlSegment + ' ';
+            }
+            else {
+                sql += 'AND `' + key + "` = '" + paramDt[key] + "'";
+            }
         }
-	}
-	
-	return sql.replace('AND ', '');
+        
+        return sql.replace('AND ', '');
+    } catch (error) {
+        this.logger('error', '模板查询生成失败', error);
+        return '';
+    }
 };
 
 /**
@@ -194,22 +225,36 @@ Sql.prototype.tplQuery = function (paramDt, sqlDt) {
  * @param {Object} paramDt - 参数对象
  * @param {Object} sqlDt - SQL模板对象
  * @returns {Object} 查询结果对象
+ * @throws {TypeError} 当参数对象无效时
  */
 Sql.prototype.tplBody = function (paramDt, sqlDt) {
-	let sql = '';
-		
-	for (const key in paramDt) {
-		if (sqlDt[key]) {
-			// 替换占位符{0}为参数值
-			const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
-			sql += ', ' + sqlSegment + ' ';
-		}
-        else {
-            sql += ', `' + key + "` = '" + paramDt[key] + "'";
+    // 参数校验
+    if (!paramDt || typeof paramDt !== 'object') {
+        throw new TypeError('paramDt must be object');
+    }
+    if (!sqlDt || typeof sqlDt !== 'object') {
+        throw new TypeError('sqlDt must be object');
+    }
+    
+    try {
+        let sql = '';
+                
+        for (const key in paramDt) {
+            if (sqlDt[key]) {
+                // 替换占位符{0}为参数值
+                const sqlSegment = sqlDt[key].replace(/\{0\}/g, paramDt[key]);
+                sql += ', ' + sqlSegment + ' ';
+            }
+            else {
+                sql += ', `' + key + "` = '" + paramDt[key] + "'";
+            }
         }
-	}
-	
-	return sql.replace(', ', '');
+        
+        return sql.replace(', ', '');
+    } catch (error) {
+        this.logger('error', '模板数据生成失败', error);
+        return '';
+    }
 };
 
 /**
@@ -217,14 +262,28 @@ Sql.prototype.tplBody = function (paramDt, sqlDt) {
  * @param {Object} paramDt - 参数对象
  * @param {Array} arr - 过滤数组
  * @returns {Object} 过滤后的参数对象
+ * @throws {TypeError} 当参数对象无效时
  */
 Sql.prototype.filter = function (paramDt, arr) {
-	for (const key in paramDt) {
-		if (arr.includes(key)) {
-            delete paramDt[key];
-		}
-	}
-	return paramDt;
+    // 参数校验
+    if (!paramDt || typeof paramDt !== 'object') {
+        throw new TypeError('paramDt must be object');
+    }
+    if (!Array.isArray(arr)) {
+        throw new TypeError('arr must be array');
+    }
+    
+    try {
+        for (const key in paramDt) {
+            if (arr.includes(key)) {
+                delete paramDt[key];
+            }
+        }
+        return paramDt;
+    } catch (error) {
+        this.logger('error', '参数过滤失败', error);
+        return {};
+    }
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_sql",
-  "version": "1.3.8",
+  "version": "1.4.0",
   "description": "一个通用的SQL帮助类，支持通过切换db_type实现对不同数据库的操作，包括MySQL和SQLite等",
   "main": "index.js",
   "scripts": {
@@ -41,7 +41,7 @@
     "node": ">=12.0.0"
   },
   "dependencies": {
-    "mm_mysql": "^2.1.1",
-    "mm_sqlite": "^1.1.2"
+    "mm_mysql": "^2.2.5",
+    "mm_sqlite": "^1.2.2"
   }
 }

package/test.js

@@ -1,4 +1,4 @@
-const {Sql} = require('./index.js');
+const { Sql } = require('./index.js');
 
 /**
  * @description Sql类测试
@@ -18,7 +18,9 @@ class SqlTest {
     async init() {
         try {
             this.sql = new Sql({
-                db_type: 'mysql',
+                // db_type: 'mysql',
+                db_type: 'sqlite',
+                dir: './db',
                 host: 'localhost',
                 user: 'root',
                 password: 'Asd159357',
@@ -39,7 +41,7 @@ class SqlTest {
         this.testCount++;
         try {
             // 测试setConfig方法
-            this.sql.setConfig({size: 50});
+            this.sql.setConfig({ size: 50 });
             if (this.sql.config.size !== 50) {
                 throw new Error('setConfig方法测试失败');
             }
@@ -68,67 +70,6 @@ class SqlTest {
         }
     }
 
-
-
-    /**
-     * @description 测试标识符处理方法
-     */
-    testIdentifierMethod() {
-        this.testCount++;
-        try {
-            // 测试MySQL标识符
-            this.sql.config.db_type = 'mysql';
-            const mysqlId = this.sql._getIdentifier('test_table');
-            if (mysqlId !== '`test_table`') {
-                throw new Error('MySQL标识符处理失败');
-            }
-
-            // 测试SQLite标识符
-            this.sql.config.db_type = 'sqlite';
-            const sqliteId = this.sql._getIdentifier('test_table');
-            if (sqliteId !== '"test_table"') {
-                throw new Error('SQLite标识符处理失败');
-            }
-
-            // 恢复默认数据库类型
-            this.sql.config.db_type = 'mysql';
-
-            console.log('标识符处理方法测试成功');
-            this.successCount++;
-            return true;
-        } catch (error) {
-            console.error('标识符处理方法测试失败:', error.message);
-            return false;
-        }
-    }
-
-    /**
-     * @description 测试连接状态方法
-     */
-    testConnectionMethods() {
-        this.testCount++;
-        try {
-            // 测试isConnected方法
-            const connected = this.sql.isConnected();
-            if (typeof connected !== 'boolean') {
-                throw new Error('isConnected方法返回值类型错误');
-            }
-
-            // 测试getConnectionInfo方法
-            const connInfo = this.sql.getConnectionInfo();
-            if (!connInfo.db_type || !connInfo.host) {
-                throw new Error('getConnectionInfo方法返回值不完整');
-            }
-
-            console.log('连接状态方法测试成功');
-            this.successCount++;
-            return true;
-        } catch (error) {
-            console.error('连接状态方法测试失败:', error.message);
-            return false;
-        }
-    }
-
     /**
      * @description 测试模板查询方法
      */
@@ -243,7 +184,27 @@ class SqlTest {
             if (!dbInstance) {
                 throw new Error('db方法返回值无效');
             }
-
+            dbInstance.createTable("user_account", {
+                user_id: 1,
+                username: "",
+                password: "",
+                gm: 1,
+                vip: 0
+            }, "user_id").then(() => {
+                console.log('创建表成功');
+            }).catch((error) => {
+                console.error('创建表失败:', error);
+            });
+            dbInstance.fields("user_account").then((result) => {
+                console.log('查询字段:', result);
+            });
+            dbInstance.table = "user_account";
+            dbInstance.get({
+                user_id: "1"
+            }).then((result) => {
+                console.log('查询结果:', result);
+            });
+            console.log('调试DB：查询方法测试完成后', dbInstance.sql, dbInstance.error);
             console.log('核心方法测试成功');
             this.successCount++;
             return true;
@@ -273,10 +234,6 @@ class SqlTest {
         console.log('调试：配置方法测试完成后');
         this.testSqlBuilderMethods();
         console.log('调试：SQL构建方法测试完成后');
-        this.testIdentifierMethod();
-        console.log('调试：标识符处理方法测试完成后');
-        this.testConnectionMethods();
-        console.log('调试：连接状态方法测试完成后');
         this.testTemplateMethods();
         console.log('调试：模板查询方法测试完成后');
         this.testCoreMethods();
@@ -284,7 +241,7 @@ class SqlTest {
 
         console.log('='.repeat(50));
         console.log(`测试完成: ${this.successCount}/${this.testCount} 个测试通过`);
-        
+
         if (this.successCount === this.testCount) {
             console.log('所有测试通过！');
             return true;

package/test2.js

@@ -1,10 +1,9 @@
 const { Sql } = require('./index.js');
-
 async function test() {
     var sql = new Sql({
         // 数据库类型 mysql, sqlite, postgres
         db_type: 'sqlite',
-        host: '/db/',
+        dir: "/db/",
         user: 'root',
         password: 'Asd159357',
         database: 'mm'
@@ -15,17 +14,35 @@ async function test() {
 
     var db = sql.db();
     db.table = "user_account";
+    // 添加表
     var res = await db.addTable('user_account', 'user_id');
-    await db.addField('user_account', 'vip', 'INT', '0');
-    await db.addField('user_account', 'gm', 'INT', '0');
     console.log("添加表结果:", res);
+    
+    // 添加字段（不需要指定表名，因为已通过db.table设置）
+    var res2 = await db.addField('age', 'INT', '0');
+    var res3 = await db.addField('sex', 'INT', '0');
+    console.log("添加字段结果:", res2, res3);
     db.key = "user_id";
     var user = await db.getObj({
         user_id: 1
     });
-    user.vip = 5;
-    user.gm = 5;
-    await $.sleep(3000);
+    
+    if (!user) {
+        // 如果用户不存在，创建一个新用户
+        user = {
+            user_id: 1,
+            vip: 5,
+            gm: 5
+        };
+        await db.add(user);
+    } else {
+        // 如果用户存在，更新其属性
+        user.vip = 5;
+        user.gm = 5;
+        await db.set({ user_id: 1 }, user);
+    }
+    // 使用原生的setTimeout实现延迟
+    await new Promise(resolve => setTimeout(resolve, 3000));
     db.size = 1;
     var list = await db.get({
         user_id: 1
@@ -33,4 +50,11 @@ async function test() {
     console.log("查询结果:", list);
 }
 
-test();
+// 调用test函数并处理异常
+test().catch(err => {
+    console.error('测试过程中发生错误:', err);
+    process.exit(1);
+}).finally(() => {
+    // 确保程序以零退出码结束
+    process.exit(0);
+});