wok-server 0.1.9 → 0.2.1

package/README.md

@@ -4,7 +4,7 @@
 
 主要功能：配置，日志，国际化，校验，缓存，MVC，mysql，mongodb ，周期任务 。
 
-[查看文档](./documentation/zh-cn/index.md)
+[查看文档](https://gitee.com/tai/wok-server/blob/master/documentation/zh-cn/index.md)
 
 ## 优点
 
@@ -39,7 +39,7 @@ startWebServer({
 
 上面的代码启动了 web 服务，访问路径 `http://localhost:8080` 将输出文本 “Hello world !”。
 
-相关的设置可以通过环境变量来修改，查看[完整文档](./documentation/zh-cn/index.md)了解细节。
+相关的设置可以通过环境变量来修改，查看[完整文档](https://gitee.com/tai/wok-server/blob/master/documentation/zh-cn/index.md)了解细节。
 
 ## 一些问题的说明
 

package/dist/cache/cache.js

@@ -79,13 +79,17 @@ class Cache {
         }
         // 创建新的异步流程
         const promise = Promise.resolve().then(async () => {
-            const finalExpireInSeconds = typeof expiresInSeconds === 'number' ? expiresInSeconds : config_1.config.defaultExpireInSeconds;
-            // 计算值
-            const res = provider();
-            const val = res instanceof Promise ? await res : res;
-            this.put(key, val, finalExpireInSeconds);
-            this.promiseMap.delete(key);
-            return val;
+            try {
+                const finalExpireInSeconds = typeof expiresInSeconds === 'number' ? expiresInSeconds : config_1.config.defaultExpireInSeconds;
+                // 计算值
+                const res = provider();
+                const val = res instanceof Promise ? await res : res;
+                this.put(key, val, finalExpireInSeconds);
+                return val;
+            }
+            finally {
+                this.promiseMap.delete(key);
+            }
         });
         this.promiseMap.set(key, promise);
         return promise;

package/dist/mvc/index.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const promises_1 = require("fs/promises");
 const http_1 = require("http");
+const https_1 = require("https");
 const os_1 = require("os");
 const path_1 = require("path");
 const log_1 = require("../log");
@@ -197,6 +198,10 @@ let SERVER;
  * @param opts
  */
 async function startWebServer(opts) {
+    (0, https_1.createServer)({
+        cert: '', key: ''
+    }, () => {
+    });
     if (SERVER) {
         throw new Error('The server has already been started!');
     }

package/dist/mysql/manager/ops/criteria.js

@@ -2,6 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildQuery = exports.MysqlCriteria = void 0;
 const exception_1 = require("../../exception");
+/**
+ * 生成条件查询中键的sql片段，包含 sql 内容和要传递的值
+ */
+function generateMysqlCriteriaKeySqlSeg(key) {
+    if (Array.isArray(key)) {
+        if (key[0] === 'json_extract') {
+            return { sqlSeg: `JSON_EXTRACT(??, ${JSON.stringify(key[2])})`, value: key[1] };
+        }
+        if (key[0] === 'json_length') {
+            return { sqlSeg: `JSON_LENGTH(??)`, value: key[1] };
+        }
+        throw new exception_1.MysqlException(`Unsupported MysqlCriteriaKey type: ${key[0]}`);
+    }
+    return { sqlSeg: '??', value: key };
+}
 /**
  * mysql 查询条件（ query criterion ），默认查询条件都是并且关系（and）， 部分方法会有例外，在使用的时候请注意方法说明。
  *
@@ -18,7 +33,7 @@ class MysqlCriteria {
      * @param value
      */
     eq(column, value) {
-        this.criteria.push({ type: 'eq', columnName: column, value });
+        this.criteria.push({ type: 'eq', key: column, value });
         return this;
     }
     /**
@@ -27,7 +42,7 @@ class MysqlCriteria {
      * @param value
      */
     neq(column, value) {
-        this.criteria.push({ type: 'neq', columnName: column, value });
+        this.criteria.push({ type: 'neq', key: column, value });
         return this;
     }
     /**
@@ -37,7 +52,7 @@ class MysqlCriteria {
      * @returns
      */
     like(column, value) {
-        this.criteria.push({ type: 'like', columnName: column, value });
+        this.criteria.push({ type: 'like', key: column, value });
         return this;
     }
     /**
@@ -47,14 +62,14 @@ class MysqlCriteria {
      * @returns
      */
     notLike(column, value) {
-        this.criteria.push({ type: 'notLike', columnName: column, value });
+        this.criteria.push({ type: 'notLike', key: column, value });
         return this;
     }
     /**
      * BETWEEN x and y
      */
     between(column, min, max) {
-        this.criteria.push({ type: 'between', columnName: column, value: [min, max] });
+        this.criteria.push({ type: 'between', key: column, value: [min, max] });
         return this;
     }
     /**
@@ -63,7 +78,7 @@ class MysqlCriteria {
      * @param value
      */
     gt(column, value) {
-        this.criteria.push({ type: 'gt', columnName: column, value });
+        this.criteria.push({ type: 'gt', key: column, value });
         return this;
     }
     /**
@@ -72,7 +87,7 @@ class MysqlCriteria {
      * @param value
      */
     gte(column, value) {
-        this.criteria.push({ type: 'gte', columnName: column, value });
+        this.criteria.push({ type: 'gte', key: column, value });
         return this;
     }
     /**
@@ -81,7 +96,7 @@ class MysqlCriteria {
      * @param value
      */
     lt(column, value) {
-        this.criteria.push({ type: 'lt', columnName: column, value });
+        this.criteria.push({ type: 'lt', key: column, value });
         return this;
     }
     /**
@@ -90,7 +105,7 @@ class MysqlCriteria {
      * @param value
      */
     lte(column, value) {
-        this.criteria.push({ type: 'lte', columnName: column, value });
+        this.criteria.push({ type: 'lte', key: column, value });
         return this;
     }
     /**
@@ -99,7 +114,7 @@ class MysqlCriteria {
      * @param values
      */
     in(column, values) {
-        this.criteria.push({ type: 'in', columnName: column, value: values });
+        this.criteria.push({ type: 'in', key: column, value: values });
         return this;
     }
     /**
@@ -108,7 +123,7 @@ class MysqlCriteria {
      * @param values
      */
     notIn(column, values) {
-        this.criteria.push({ type: 'notIn', columnName: column, value: values });
+        this.criteria.push({ type: 'notIn', key: column, value: values });
         return this;
     }
     /**
@@ -137,7 +152,7 @@ class MysqlCriteria {
      * @returns
      */
     isNull(field) {
-        this.criteria.push({ type: 'isNull', columnName: field });
+        this.criteria.push({ type: 'isNull', key: field });
         return this;
     }
     /**
@@ -146,7 +161,7 @@ class MysqlCriteria {
      * @returns
      */
     isNotNull(field) {
-        this.criteria.push({ type: 'isNotNull', columnName: field });
+        this.criteria.push({ type: 'isNotNull', key: field });
         return this;
     }
     /**
@@ -168,7 +183,7 @@ class MysqlCriteria {
                 criterion.criteria.check();
                 continue;
             }
-            if (!criterion.columnName) {
+            if (!criterion.key) {
                 throw new exception_1.MysqlException('The column name of the query criteria cannot be blank.');
             }
             if (criterion.type === 'isNull' || criterion.type === 'isNotNull') {
@@ -176,19 +191,19 @@ class MysqlCriteria {
             }
             if (criterion.type === 'in' || criterion.type === 'notIn') {
                 if (!Array.isArray(criterion.value)) {
-                    throw new exception_1.MysqlException(`Invalid ${criterion.type} condition，the condition value is not a array type，column name：${criterion.columnName.toString()}`);
+                    throw new exception_1.MysqlException(`Invalid ${criterion.type} condition，the condition value is not a array type，column name：${criterion.key.toString()}`);
                 }
                 if (!criterion.value.length) {
-                    throw new exception_1.MysqlException(`Invalid ${criterion.type} condition，the condition value cannot be an empty array，column name：${criterion.columnName.toString()}`);
+                    throw new exception_1.MysqlException(`Invalid ${criterion.type} condition，the condition value cannot be an empty array，column name：${criterion.key.toString()}`);
                 }
                 continue;
             }
             if (criterion.type === 'between') {
                 if (!Array.isArray(criterion.value)) {
-                    throw new exception_1.MysqlException(`Invalid between condition，the condition value is not an array type，column name：${criterion.columnName.toString()}, value:${criterion.value}`);
+                    throw new exception_1.MysqlException(`Invalid between condition，the condition value is not an array type，column name：${criterion.key.toString()}, value:${criterion.value}`);
                 }
                 if (criterion.value.length !== 2) {
-                    throw new exception_1.MysqlException(`Invalid between condition，the condition value must be an array of length 2，column: ${criterion.columnName.toString()}，value：${criterion.value.length}`);
+                    throw new exception_1.MysqlException(`Invalid between condition，the condition value must be an array of length 2，column: ${criterion.key.toString()}，value：${criterion.value.length}`);
                 }
                 continue;
             }
@@ -196,7 +211,7 @@ class MysqlCriteria {
                 typeof criterion.value !== 'string' &&
                 !(criterion.value instanceof Date)) {
                 throw new exception_1.MysqlException('The value of the query criteria is invalid，only number,string and Date are supported，' +
-                    `column name : ${criterion.columnName.toString()}，value : ${criterion.value} .`);
+                    `column name : ${criterion.key.toString()}，value : ${criterion.value} .`);
             }
         }
     }
@@ -209,11 +224,11 @@ class MysqlCriteria {
         const values = [];
         for (const criterion of this.criteria) {
             // 普通的查询
-            if (criterion.columnName && criterion.value !== undefined) {
+            if (criterion.key && criterion.value !== undefined) {
                 // between 特殊处理
                 if (criterion.type === 'between') {
                     sqlFragments.push('and ?? between ? and ? ');
-                    values.push(criterion.columnName, criterion.value[0], criterion.value[1]);
+                    values.push(criterion.key, criterion.value[0], criterion.value[1]);
                     continue;
                 }
                 // 符号
@@ -249,25 +264,27 @@ class MysqlCriteria {
                     sign = 'not like';
                 }
                 if (sign) {
+                    const keySeg = generateMysqlCriteriaKeySqlSeg(criterion.key);
                     if (criterion.type === 'in' || criterion.type === 'notIn') {
-                        sqlFragments.push(`and ?? ${sign} (?) `);
+                        sqlFragments.push(`and ${keySeg.sqlSeg} ${sign} (?) `);
                     }
                     else {
-                        sqlFragments.push(`and ?? ${sign} ? `);
+                        sqlFragments.push(`and ${keySeg.sqlSeg} ${sign} ? `);
                     }
-                    values.push(criterion.columnName, criterion.value);
+                    values.push(keySeg.value, criterion.value);
                 }
                 continue;
             }
-            else if (criterion.columnName) {
+            else if (criterion.key) {
+                const keySeg = generateMysqlCriteriaKeySqlSeg(criterion.key);
                 if (criterion.type === 'isNull') {
-                    sqlFragments.push(`and ?? is null `);
-                    values.push(criterion.columnName);
+                    sqlFragments.push(`and ${keySeg.sqlSeg} is null `);
+                    values.push(keySeg.value);
                     continue;
                 }
                 if (criterion.type === 'isNotNull') {
-                    sqlFragments.push(`and ?? is not null `);
-                    values.push(criterion.columnName);
+                    sqlFragments.push(`and ${keySeg.sqlSeg} is not null `);
+                    values.push(keySeg.value);
                     continue;
                 }
             }

package/dist/mysql/manager/ops/insert.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertMany = exports.insert = void 0;
 const exception_1 = require("../../exception");
 const utils_1 = require("../utils");
+const utils_2 = require("./utils");
 /**
  * 为表插入数据
  * @param connection
@@ -34,7 +35,11 @@ async function insert(config, connection, table, data) {
     const sql = `insert into ??(${columns.map(() => '??').join(',')}) values(${columns
         .map(() => '?')
         .join(',')})`;
-    const values = [table.tableName, ...columns, ...columns.map(col => data[col])];
+    const values = [
+        table.tableName,
+        ...columns,
+        ...columns.map(col => (0, utils_2.processColumnValue)(data[col]))
+    ];
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const packet = res;
     if (packet.affectedRows !== 1) {
@@ -89,7 +94,7 @@ async function insertMany(config, connection, table, list) {
         if (table.updatedDate) {
             data[table.updatedDate.column] = updatedDate;
         }
-        values.push(...columns.map(col => data[col]));
+        values.push(...columns.map(col => (0, utils_2.processColumnValue)(data[col])));
     });
     const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
     const rsh = res;

package/dist/mysql/manager/ops/update.js

@@ -4,6 +4,7 @@ exports.updateMany = exports.updateOne = exports.partialUpdate = exports.update
 const exception_1 = require("../../exception");
 const criteria_1 = require("./criteria");
 const utils_1 = require("../utils");
+const utils_2 = require("./utils");
 /**
  * 更新
  * @param config
@@ -30,7 +31,7 @@ async function update(config, connection, table, data) {
     // 值
     const values = [
         table.tableName,
-        ...columns.flatMap(col => [col, data[col]]),
+        ...columns.flatMap(col => [col, (0, utils_2.processColumnValue)(data[col])]),
         table.id,
         data[table.id]
     ];
@@ -79,7 +80,7 @@ function updatorToSql(table, updater) {
             continue;
         }
         updateFragList.push(' ?? = ? ');
-        values.push(column, val);
+        values.push(column, (0, utils_2.processColumnValue)(val));
     }
     return { sql: updateFragList.join(','), values };
 }

package/dist/mysql/manager/ops/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processColumnValue = void 0;
+/**
+ * 处理列的值，对特殊类型 json 进行加工处理后返回
+ * @param value
+ */
+function processColumnValue(value) {
+    // date 类型 typeof 也是 object ，先排除
+    if (value instanceof Date) {
+        return value;
+    }
+    // json
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    // 其它的情况直接返回
+    return value;
+}
+exports.processColumnValue = processColumnValue;

package/documentation/zh-cn/mysql.md

@@ -151,12 +151,14 @@ export const tableUser: Table<User> = {
 实体类字段和查询方法的返回对象的字段有一套类型映射规则，这个需要写的时间注意，**数据库里是什么类型，就必须写对应的 js 原生类型**。
 类型映射逻辑不支持修改，下面是对照表：
 
-| js 原生类型 | mysql 字段类型                                                       |
-| :---------- | :------------------------------------------------------------------- |
-| Number      | TINYINT,SMALLINT,INT,MEDIUMINT,YEAR.FLOAT,DOUBLE,BIGINT              |
-| Date        | TIMESTAMP,DATE,DATETIME                                              |
-| Buffer      | TINYBLOB,MEDIUMBLOB,LONGBLOB,BLOB,BINARY,VARBINARY,BIT               |
-| String      | CHAR,VARCHAR,TINYTEXT,MEDIUMTEXT,LONGTEXT,TEXT,ENUM,SET,DECIMAL,TIME |
+| js 原生类型     | mysql 字段类型                                                       |
+| :-------------- | :------------------------------------------------------------------- |
+| Boolean         | TINYINT                                                              |
+| Number          | TINYINT,SMALLINT,INT,MEDIUMINT,YEAR.FLOAT,DOUBLE,BIGINT              |
+| Date            | TIMESTAMP,DATE,DATETIME                                              |
+| Buffer          | TINYBLOB,MEDIUMBLOB,LONGBLOB,BLOB,BINARY,VARBINARY,BIT               |
+| String          | CHAR,VARCHAR,TINYTEXT,MEDIUMTEXT,LONGTEXT,TEXT,ENUM,SET,DECIMAL,TIME |
+| Object 或 Array | JSON                                                                 |
 
 对于可空字段，可以在 ts 里也定义为可空：
 
@@ -303,6 +305,108 @@ await manager.modify(`update user set nickname='无名' where nickname='佚名'`
 | query         | 自定义 sql 查询，返回记录列表，支持预编译 sql                               |
 | modify        | 执行自定义 sql，返回操作记录数 ，支持预编译 sql                             |
 
+### json 类型
+
+0.2.0 版本开始增加了对 JSON 类型的有限支持，可以正常插入和查询，过滤条件也部分支持了 mysql 的 json 相关函数。
+相比使用字符类型来存储 json ，然后在程序里反序列化解析，使用 json 格式要方便很多，开发更高效。
+下面是一个完整的例子。
+
+数据库建表语句，字段的类型设置为 json 。
+
+```sql
+CREATE TABLE
+  question (
+    id VARCHAR(32) PRIMARY KEY,
+    title VARCHAR(256) NOT NULL COMMENT '标题',
+    options json NOT NULL COMMENT '选项列表，json 数组',
+    question_setter json NOT NULL COMMENT '出题人信息，json 对象',
+    create_at BIGINT UNSIGNED NOT NULL COMMENT '创建时间',
+    update_at BIGINT UNSIGNED NOT NULL COMMENT '更新时间'
+  ) ENGINE = InnoDB DEFAULT CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci COMMENT = '试题';
+```
+
+表映射配置，json 类型对应的字段申明为自定义的格式即可。
+
+```ts
+// 选项
+export interface QuesOption {
+  title: string
+  correct?: boolean
+}
+// 出题人
+export interface QuestionSetter {
+  id: string
+  name: string
+}
+// 试题
+export interface Question {
+  id: string
+  title: string
+  // 选项
+  options: QuesOption[]
+  // 出题人
+  question_setter: QuestionSetter
+  create_at?: number
+  update_at?: number
+}
+
+export const tableQuestion: Table<Question> = {
+  tableName: 'question',
+  id: 'id',
+  columns: ['title', 'options', 'question_setter'],
+  createdDate: {
+    type: 'number',
+    column: 'create_at'
+  },
+  updatedDate: {
+    type: 'number',
+    column: 'update_at'
+  }
+}
+```
+
+常用的方法，使用起来没有任何区别，json 按字段定义的格式传递数据即可。
+
+```ts
+await getMysqlManager().insert(tableQuestion, {
+  id: '003',
+  title: '下面哪个类型是 Mysql 不支持的',
+  options: [
+    { title: 'TINYINT' },
+    { title: 'BOOLEAN', correct: true },
+    { title: 'CHAR' },
+    { title: 'TEXT' }
+  ],
+  question_setter: { id: 'x333', name: '小李老师' }
+})
+// 查询到的数据是完整的，不需要再做任何处理，相应的 json 字段就是对应的类型
+const q1 = await  getMysqlManager().findById(tableQuestion, '003')
+q1.question_setter.name // 小李老师
+```
+
+查询条件支持 json_extract 和 json_length，凡是支持查询条件的地方都可以使用，
+使用时不能再传递列名，取而代之的是一个元组。
+
+```ts
+await mananger.findFirst(tableQuestion, c =>
+  // 查询 question_setter 字段下的属性 id 为 x333 的记录
+  c.eq(['json_extract', 'question_setter', '$.id'], 'x333')
+)
+await mananger.findFirst(tableQuestion, c =>
+  // 查询 options 字段中第一个元素的 title 属性为 地球 的记录
+  c.eq(['json_extract', 'options', '$[0].title'], '地球')
+)
+await mananger.find({
+  table: tableQuestion,
+  // 查询 options 字段的元素数量大于等于 5 的记录，也就是查询选项多于5个的试题
+  criteria: c => c.gte(['json_length', 'options'], 5)
+})
+```
+
+json_extract 和 json_length 查询都需要传递元组，第一个参数就是查询的类型，第二个参数是字段名称，
+json_extract 还有第三个参数是属性路径。属性路径的格式和 js 获取属性的语法是一样的，只是用 $ 来指代字段的值。
+
+
 ### 预编译 sql
 
 使用 query 或 midify 方法传入自定义 sql 时，sql 是支持预编译的，参数值使用 ? (问号)来占位，表名和

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wok-server",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "packageManager": "pnpm@8.9.0",
   "description": "一个基于 NodeJs 和 TypeScript 的后端框架，轻量级、克制、简洁。A lightweight, restrained, and concise backend framework based on Node.js and TypeScript.",
   "scripts": {
@@ -23,6 +23,11 @@
   ],
   "author": "peak",
   "license": "ISC",
+  "homepage": "https://gitee.com/tai/wok-server",
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/tai/wok-server.git"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },

package/types/mysql/manager/ops/criteria.d.ts

@@ -2,6 +2,14 @@ export interface MysqlQuery {
     sql: string;
     values: any[];
 }
+/**
+ * mysql 查询条件中的键，左侧表达式，可以是提取信息的表达式，也可以直接是列名
+ *
+ * keyof T 列名，直接用列的值来比较
+ * ['json_extract', keyof T, string] 使用 json_extract 函数提取 json 信息，第二个参数是列名，最后一个参数是表达式（如：'$.name'）
+ * ['json_length',keyof T] 使用 json_length 函数提取 json 数组的元素数量
+ */
+export type MysqlCriteriaKey<T> = keyof T | ['json_extract', keyof T, string] | ['json_length', keyof T];
 /**
  * mysql 查询条件（ query criterion ），默认查询条件都是并且关系（and）， 部分方法会有例外，在使用的时候请注意方法说明。
  *
@@ -17,67 +25,67 @@ export declare class MysqlCriteria<T> {
      * @param column
      * @param value
      */
-    eq(column: keyof T, value: any): this;
+    eq(column: MysqlCriteriaKey<T>, value: any): this;
     /**
      * 不等于，注意不相等不能走索引，谨慎使用
      * @param column
      * @param value
      */
-    neq(column: keyof T, value: any): this;
+    neq(column: MysqlCriteriaKey<T>, value: any): this;
     /**
      * like
      * @param column
      * @param value
      * @returns
      */
-    like(column: keyof T, value: string): this;
+    like(column: MysqlCriteriaKey<T>, value: string): this;
     /**
      * not like
      * @param column
      * @param value
      * @returns
      */
-    notLike(column: keyof T, value: string): this;
+    notLike(column: MysqlCriteriaKey<T>, value: string): this;
     /**
      * BETWEEN x and y
      */
-    between(column: keyof T, min: number, max: number): this;
+    between(column: MysqlCriteriaKey<T>, min: number, max: number): this;
     /**
      * 大于
      * @param column
      * @param value
      */
-    gt(column: keyof T, value: number | Date | string): this;
+    gt(column: MysqlCriteriaKey<T>, value: number | Date | string): this;
     /**
      * 大于等于
      * @param column
      * @param value
      */
-    gte(column: keyof T, value: number | Date | string): this;
+    gte(column: MysqlCriteriaKey<T>, value: number | Date | string): this;
     /**
      * 小于
      * @param column
      * @param value
      */
-    lt(column: keyof T, value: number | Date | string): this;
+    lt(column: MysqlCriteriaKey<T>, value: number | Date | string): this;
     /**
      * 小于等于
      * @param column
      * @param value
      */
-    lte(column: keyof T, value: number | Date | string): this;
+    lte(column: MysqlCriteriaKey<T>, value: number | Date | string): this;
     /**
      * in 条件
      * @param column
      * @param values
      */
-    in(column: keyof T, values: Array<string | number>): this;
+    in(column: MysqlCriteriaKey<T>, values: Array<string | number>): this;
     /**
      * not in 条件
      * @param column
      * @param values
      */
-    notIn(column: keyof T, values: Array<string | number>): this;
+    notIn(column: MysqlCriteriaKey<T>, values: Array<string | number>): this;
     /**
      * 嵌入其它的查询条件，与现有的查询条件是或者关系.
      * @param criteria
@@ -93,13 +101,13 @@ export declare class MysqlCriteria<T> {
      * @param field
      * @returns
      */
-    isNull(field: keyof T): this;
+    isNull(field: MysqlCriteriaKey<T>): this;
     /**
      * 字段非空
      * @param field
      * @returns
      */
-    isNotNull(field: keyof T): this;
+    isNotNull(field: MysqlCriteriaKey<T>): this;
     /**
      * 判定是否空，未设置条件.
      * @returns

package/types/mysql/manager/ops/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 处理列的值，对特殊类型 json 进行加工处理后返回
+ * @param value
+ */
+export declare function processColumnValue(value: any): any;