wok-server 0.1.0

package/dist/mysql/manager/base.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMysqlManager = void 0;
+const exception_1 = require("../exception");
+const ops_1 = require("./ops");
+const utils_1 = require("./utils");
+/**
+ * mysql 管理器基类，提供基础的操作方法.
+ */
+class BaseMysqlManager {
+    opts;
+    /**
+     * @param mapping 映射
+     */
+    constructor(
+    /**
+     * 选项，连接池和连接必须有一个，连接池优先.
+     */
+    opts) {
+        this.opts = opts;
+        if (!opts.pool && !opts.connection) {
+            throw new exception_1.MysqlException('Pool and Connection cannot be both null.');
+        }
+    }
+    async queryWithConnection(queryFn) {
+        let conn;
+        if (this.opts.pool) {
+            conn = await (0, utils_1.promiseGetConnection)(this.opts.pool);
+        }
+        else if (this.opts.connection) {
+            conn = this.opts.connection;
+        }
+        if (!conn) {
+            throw new exception_1.MysqlException('Unable to obtain connection');
+        }
+        try {
+            return queryFn(conn);
+        }
+        finally {
+            // 如果是连接池来的，每次连接都是新建，必须释放掉
+            if (this.opts.pool) {
+                this.opts.pool.releaseConnection(conn);
+            }
+        }
+    }
+    /**
+     * 依据id查找.
+     * @param table 表信息
+     * @param id id
+     * @returns
+     */
+    findById(table, id) {
+        return this.queryWithConnection(conn => (0, ops_1.findById)(this.opts.config, conn, table, id));
+    }
+    /**
+     * 根据id列表查询
+     * @param table
+     * @param ids
+     * @returns
+     */
+    findByIdIn(table, ids) {
+        return this.queryWithConnection(conn => (0, ops_1.findByIdIn)(this.opts.config, conn, table, ids));
+    }
+    /**
+     * 根据条件判定是否存在记录.
+     * @param table
+     * @param criteria  条件信息，可以为空，为空的情况下判定整个表是否有记录
+     * @returns
+     */
+    existsBy(table, criteria) {
+        return this.queryWithConnection(conn => (0, ops_1.existsBy)(this.opts.config, conn, table, criteria));
+    }
+    /**
+     * 根据id判定记录是否存在
+     * @param table
+     * @param id
+     * @returns
+     */
+    existsById(table, id) {
+        return this.queryWithConnection(conn => (0, ops_1.existsById)(this.opts.config, conn, table, id));
+    }
+    /**
+     * 按 id 查询
+     * @param table 表信息
+     * @param id
+     */
+    deleteById(table, id) {
+        return this.queryWithConnection(conn => (0, ops_1.deleteById)(this.opts.config, conn, table, id));
+    }
+    /**
+     * 按条件删除数据。批量删除是危险操作，建议在使用时尽可能设置 limit 参数来限制数量。
+     * @param opts
+     * @returns
+     */
+    deleteMany(opts) {
+        return this.queryWithConnection(conn => (0, ops_1.deleteMany)(this.opts.config, conn, opts));
+    }
+    /**
+     * 仅删除符合条件的一条记录，必须是相等条件
+     * @param table
+     * @param criteria
+     * @returns
+     */
+    async deleteOne(table, criteria) {
+        if (!Object.keys(criteria).length) {
+            throw new exception_1.MysqlException('criteria cannot be empty !');
+        }
+        const res = await this.queryWithConnection(conn => (0, ops_1.deleteMany)(this.opts.config, conn, {
+            table,
+            criteria,
+            limit: 1
+        }));
+        return res === 1;
+    }
+    /**
+     * 查询表中所有数据.
+     * @param table  表信息
+     * @returns
+     */
+    findAll(table) {
+        return this.queryWithConnection(conn => (0, ops_1.findAll)(this.opts.config, conn, table));
+    }
+    /**
+     * 按条件查询第一条记录.
+     * @param table
+     * @param criteria
+     * @returns
+     */
+    findFirst(table, criteria) {
+        return this.queryWithConnection(conn => (0, ops_1.findFirst)(this.opts.config, conn, table, criteria));
+    }
+    /**
+     * 插入数据. 不支持自增加长id,id必须提前生成，请使用 uuid.
+     * @param table 表信息
+     * @param data 数据，数据必须是 T 的实例, T 必须是已配置的实体类类型，否则无法完成操作
+     * @returns 插入后的数据
+     */
+    insert(table, data) {
+        return this.queryWithConnection(conn => (0, ops_1.insert)(this.opts.config, conn, table, data));
+    }
+    /**
+     * 批量插入
+     * @param table 表
+     * @param list 要插入的数据列表
+     */
+    insertMany(table, list) {
+        return this.queryWithConnection(conn => (0, ops_1.insertMany)(this.opts.config, conn, table, list));
+    }
+    /**
+     * 更新
+     * @param table 表信息
+     * @param data
+     */
+    update(table, data) {
+        return this.queryWithConnection(conn => (0, ops_1.update)(this.opts.config, conn, table, data));
+    }
+    /**
+     * 更新所以匹配条件的记录
+     * @param opts
+     * @returns
+     */
+    updateMany(opts) {
+        return this.queryWithConnection(conn => (0, ops_1.updateMany)(this.opts.config, conn, opts));
+    }
+    /**
+     * 只更新一条记录。仅支持相等条件，不支持范围条件，可以严格事务中使用。
+     * @param table
+     * @param criteria
+     * @param updater
+     * @returns 更新是否成功
+     */
+    updateOne(table, criteria, updater) {
+        if (!Object.keys(criteria).length) {
+            throw new exception_1.MysqlException('criteria cannot be empty !');
+        }
+        if (!Object.keys(updater).length) {
+            throw new exception_1.MysqlException('updater cannot be empty !');
+        }
+        return this.queryWithConnection(conn => (0, ops_1.updateOne)(this.opts.config, conn, table, criteria, updater));
+    }
+    /**
+     * 部分更新
+     * @param table 表信息
+     * @param data 字段信息，必须要包含id字段，如果包含了更新和创建时间的字段，则忽略掉
+     */
+    partialUpdate(table, data) {
+        return this.queryWithConnection(conn => (0, ops_1.partialUpdate)(this.opts.config, conn, table, data));
+    }
+    /**
+     * 查找实体类 自定义条件
+     * @param opts
+     * @returns
+     */
+    find(opts) {
+        return this.queryWithConnection(conn => (0, ops_1.find)(this.opts.config, conn, opts));
+    }
+    /**
+     * 指定条件查询数量
+     * @param table 表信息
+     * @param criteria 查询条件
+     * @returns
+     */
+    count(table, criteria) {
+        return this.queryWithConnection(conn => (0, ops_1.count)(this.opts.config, conn, table, criteria));
+    }
+    /**
+     * 分页查询
+     * @param opts
+     * @returns
+     */
+    paginate(opts) {
+        return this.queryWithConnection(conn => (0, ops_1.paginate)(this.opts.config, conn, opts));
+    }
+    /**
+     * 自定义查询，指定 sql 、参数和返回值类型
+     * @param sql 预编译 sql ，参数使用 ”?“（英文问号） 占位，注意查询的字段名称会与返回值类型的字段映射，如果 sql 中的字段名称很特殊（比如纯数字等），需要设置别名，避免产生映射错误
+     * @param values 要传递的值，对应 sql 中的占位符 ”?“（英文问号）
+     * @param T 返回值类型，注意类型映射问题，详细可以参考文档中关于类型映射的说明
+     */
+    async query(sql, values) {
+        return this.queryWithConnection(conn => (0, ops_1.query)(this.opts.config, conn, sql, values));
+    }
+    /**
+     * 自定义 sql 执行，必须是修改类的 sql ，否则会发生错误
+     * @param sql
+     * @param values
+     * @returns 返回影响的行数
+     */
+    async modify(sql, values) {
+        return this.queryWithConnection(conn => (0, ops_1.modify)(this.opts.config, conn, sql, values));
+    }
+}
+exports.BaseMysqlManager = BaseMysqlManager;

package/dist/mysql/manager/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlTxSession = exports.BaseMysqlManager = exports.MysqlCriteria = exports.MysqlManager = void 0;
+const base_1 = require("./base");
+Object.defineProperty(exports, "BaseMysqlManager", { enumerable: true, get: function () { return base_1.BaseMysqlManager; } });
+const tx_1 = require("./tx");
+Object.defineProperty(exports, "MysqlTxSession", { enumerable: true, get: function () { return tx_1.MysqlTxSession; } });
+const utils_1 = require("./utils");
+const tx_strict_1 = require("./tx-strict");
+const exception_1 = require("../exception");
+/**
+ * mysql 管理器，封装数据库操作，提供方便使用的实体类操作方法.
+ */
+class MysqlManager extends base_1.BaseMysqlManager {
+    config;
+    pool;
+    /**
+     * @param mapping 映射
+     */
+    constructor(config, 
+    /**
+     * 连接池.
+     */
+    pool) {
+        super({ config, pool });
+        this.config = config;
+        this.pool = pool;
+    }
+    /**
+     * 事务. 所有事务中的操作都必须使用 exec 函数中提供的 session 对象，直接使用 MysqlManager 上的方法
+     * 进行的操作不会在事务中生效.
+     * @param ops 逻辑执行函数，内部的所有逻辑都必须在函数内执行完，
+     * 不得有操作在函数外异步执行（异步操作不 await，或使用定时器单独执行等），否则不会在事务中生效
+     * @param opts 选项，可设置超时时间等
+     */
+    async tx(ops, opts) {
+        const conn = await (0, utils_1.promiseGetConnection)(this.pool);
+        if (opts && opts.isolationLevel) {
+            await (0, utils_1.promiseQuery)(this.config, conn, `SET TRANSACTION ISOLATION LEVEL ${opts.isolationLevel}`);
+        }
+        if (opts && opts.accessMode) {
+            await (0, utils_1.promiseQuery)(this.config, conn, `SET TRANSACTION ${opts.accessMode}`);
+        }
+        await new Promise((resolve, reject) => {
+            conn.beginTransaction(err => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        // 构建 session ，然后执行查询
+        const session = this.config.transactionStrict
+            ? new tx_strict_1.MysqlStrictTxSession(this.config, conn)
+            : new tx_1.MysqlTxSession(this.config, conn);
+        try {
+            // 超时抛出异常
+            const timeout = opts && typeof opts.timeout === 'number' ? opts.timeout : this.config.transactionTimeout;
+            const result = timeout > 0
+                ? await Promise.race([
+                    ops(session),
+                    new Promise((resolve, reject) => {
+                        setTimeout(() => {
+                            // 立即中止会话，防止再有后续操作
+                            session.abort();
+                            reject(new exception_1.MysqlException('Transaction timeout !'));
+                        }, timeout);
+                    })
+                ])
+                : await ops(session);
+            await new Promise((resolve, reject) => {
+                conn.commit(err => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+            return result;
+        }
+        catch (e) {
+            await new Promise((resolve, reject) => {
+                conn.rollback(err => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+            throw e;
+        }
+        finally {
+            // 无论如何中止会话，离开事务，会话就不能再被使用
+            session.abort();
+            this.pool.releaseConnection(conn);
+        }
+    }
+}
+exports.MysqlManager = MysqlManager;
+var ops_1 = require("./ops");
+Object.defineProperty(exports, "MysqlCriteria", { enumerable: true, get: function () { return ops_1.MysqlCriteria; } });

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.count = void 0;
+const criteria_1 = require("./criteria");
+const utils_1 = require("../utils");
+/**
+ * 按条件统计数量.
+ * @param config
+ * @param conn
+ * @param table
+ * @param criteria
+ * @returns
+ */
+async function count(config, conn, table, criteria) {
+    let query = criteria ? (0, criteria_1.buildQuery)(criteria) : undefined;
+    const res = await (0, utils_1.promiseQuery)(config, conn, `select count(*) as ct from ?? ${query ? `where ${query.sql}` : ''} `, [table.tableName].concat(query ? query.values : []));
+    const row = res;
+    return row[0].ct;
+}
+exports.count = count;

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

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuery = exports.MysqlCriteria = void 0;
+const exception_1 = require("../../exception");
+/**
+ * mysql 查询条件（ query criterion ），默认查询条件都是并且关系（and）， 部分方法会有例外，在使用的时候请注意方法说明。
+ *
+ * @param <T> 表类型
+ */
+class MysqlCriteria {
+    /**
+     * 条件列表.
+     */
+    criteria = [];
+    /**
+     * 相等.
+     * @param column
+     * @param value
+     */
+    eq(column, value) {
+        this.criteria.push({ type: 'eq', columnName: column, value });
+        return this;
+    }
+    /**
+     * 不等于，注意不相等不能走索引，谨慎使用
+     * @param column
+     * @param value
+     */
+    neq(column, value) {
+        this.criteria.push({ type: 'neq', columnName: column, value });
+        return this;
+    }
+    /**
+     * like
+     * @param column
+     * @param value
+     * @returns
+     */
+    like(column, value) {
+        this.criteria.push({ type: 'like', columnName: column, value });
+        return this;
+    }
+    /**
+     * not like
+     * @param column
+     * @param value
+     * @returns
+     */
+    notLike(column, value) {
+        this.criteria.push({ type: 'notLike', columnName: column, value });
+        return this;
+    }
+    /**
+     * BETWEEN x and y
+     */
+    between(column, min, max) {
+        this.criteria.push({ type: 'between', columnName: column, value: [min, max] });
+        return this;
+    }
+    /**
+     * 大于
+     * @param column
+     * @param value
+     */
+    gt(column, value) {
+        this.criteria.push({ type: 'gt', columnName: column, value });
+        return this;
+    }
+    /**
+     * 大于等于
+     * @param column
+     * @param value
+     */
+    gte(column, value) {
+        this.criteria.push({ type: 'gte', columnName: column, value });
+        return this;
+    }
+    /**
+     * 小于
+     * @param column
+     * @param value
+     */
+    lt(column, value) {
+        this.criteria.push({ type: 'lt', columnName: column, value });
+        return this;
+    }
+    /**
+     * 小于等于
+     * @param column
+     * @param value
+     */
+    lte(column, value) {
+        this.criteria.push({ type: 'lte', columnName: column, value });
+        return this;
+    }
+    /**
+     * in 条件
+     * @param column
+     * @param values
+     */
+    in(column, values) {
+        this.criteria.push({ type: 'in', columnName: column, value: values });
+        return this;
+    }
+    /**
+     * 嵌入其它的查询条件，与现有的查询条件是或者关系.
+     * @param criteria
+     */
+    or(orCriteria) {
+        const criteria = new MysqlCriteria();
+        orCriteria(criteria);
+        this.criteria.push({ type: 'or', criteria });
+        return this;
+    }
+    /**
+     * 嵌入其它的查询条件，与现有的查询条件是并且关系.
+     * @param criteria
+     */
+    and(andCriteria) {
+        const criteria = new MysqlCriteria();
+        andCriteria(criteria);
+        this.criteria.push({ type: 'and', criteria });
+        return this;
+    }
+    /**
+     * 字段为空
+     * @param field
+     * @returns
+     */
+    isNull(field) {
+        this.criteria.push({ type: 'isNull', columnName: field });
+        return this;
+    }
+    /**
+     * 字段非空
+     * @param field
+     * @returns
+     */
+    isNotNull(field) {
+        this.criteria.push({ type: 'isNotNull', columnName: field });
+        return this;
+    }
+    /**
+     * 判定是否空，未设置条件.
+     * @returns
+     */
+    isEmpty() {
+        return !this.criteria.length;
+    }
+    /**
+     * 检查条件信息是否有效，在出错时能给予较详细的提示，以方便排查.
+     */
+    check() {
+        for (const criterion of this.criteria) {
+            if (criterion.type === 'or' || criterion.type === 'and') {
+                if (!criterion.criteria) {
+                    throw new exception_1.MysqlException(`${criterion.type} clause cannot be empty`);
+                }
+                criterion.criteria.check();
+                continue;
+            }
+            if (!criterion.columnName) {
+                throw new exception_1.MysqlException('The column name of the query criteria cannot be blank.');
+            }
+            if (criterion.type === 'isNull' || criterion.type === 'isNotNull') {
+                continue;
+            }
+            if (criterion.type === 'in') {
+                if (!Array.isArray(criterion.value)) {
+                    throw new exception_1.MysqlException(`Invalid in condition，the condition value is not a array type，column name：${criterion.columnName.toString()}`);
+                }
+                if (!criterion.value.length) {
+                    throw new exception_1.MysqlException(`Invalid in condition，the condition value cannot be an empty array，column name：${criterion.columnName.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}`);
+                }
+                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}`);
+                }
+                continue;
+            }
+            if (typeof criterion.value !== 'number' &&
+                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} .`);
+            }
+        }
+    }
+    /**
+     * 生成查询数据
+     */
+    generateQuery() {
+        this.check();
+        const sqlFragments = [];
+        const values = [];
+        for (const criterion of this.criteria) {
+            // 普通的查询
+            if (criterion.columnName && criterion.value !== undefined) {
+                // between 特殊处理
+                if (criterion.type === 'between') {
+                    sqlFragments.push('and ?? between ? and ? ');
+                    values.push(criterion.columnName, criterion.value[0], criterion.value[1]);
+                    continue;
+                }
+                // 符号
+                let sign = '';
+                if (criterion.type === 'eq') {
+                    sign = '=';
+                }
+                else if (criterion.type === 'neq') {
+                    sign = '!=';
+                }
+                else if (criterion.type === 'gt') {
+                    sign = '>';
+                }
+                else if (criterion.type === 'gte') {
+                    sign = '>=';
+                }
+                else if (criterion.type === 'lt') {
+                    sign = '<';
+                }
+                else if (criterion.type === 'lte') {
+                    sign = '<=';
+                }
+                else if (criterion.type === 'in') {
+                    sign = 'in';
+                }
+                else if (criterion.type === 'like') {
+                    sign = 'like';
+                }
+                else if (criterion.type === 'notLike') {
+                    sign = 'not like';
+                }
+                if (sign) {
+                    if (criterion.type === 'in') {
+                        sqlFragments.push(`and ?? ${sign} (?) `);
+                    }
+                    else {
+                        sqlFragments.push(`and ?? ${sign} ? `);
+                    }
+                    values.push(criterion.columnName, criterion.value);
+                }
+                continue;
+            }
+            else if (criterion.columnName) {
+                if (criterion.type === 'isNull') {
+                    sqlFragments.push(`and ?? is null `);
+                    values.push(criterion.columnName);
+                    continue;
+                }
+                if (criterion.type === 'isNotNull') {
+                    sqlFragments.push(`and ?? is not null `);
+                    values.push(criterion.columnName);
+                    continue;
+                }
+            }
+            // 特殊查询 or 和 and
+            else if (criterion.criteria) {
+                const query = criterion.criteria.generateQuery();
+                if (criterion.type === 'or') {
+                    sqlFragments.push(`or (${query.sql}) `);
+                    values.push(...query.values);
+                    continue;
+                }
+                if (criterion.type === 'and') {
+                    sqlFragments.push(`and (${query.sql}) `);
+                    values.push(...query.values);
+                    continue;
+                }
+            }
+        }
+        if (!sqlFragments.length) {
+            throw new exception_1.MysqlException('No valid query criteria have been set.');
+        }
+        let sql = sqlFragments.join('');
+        // 去除掉第一个条件的连接关键字，可能是 and 或 or
+        if (sql.startsWith('and')) {
+            sql = sql.substring(3);
+        }
+        else if (sql.startsWith('or')) {
+            sql = sql.substring(2);
+        }
+        return { sql, values };
+    }
+}
+exports.MysqlCriteria = MysqlCriteria;
+function convertToCriteria(example) {
+    const criteria = new MysqlCriteria();
+    Object.entries(example).forEach(entry => {
+        const [key, value] = entry;
+        criteria.eq(key, value);
+    });
+    return criteria;
+}
+/**
+ * 将混合的查询条件转换成查询语句，如果最终构建的条件是空的，返回 undefined
+ * @param criteria
+ * @returns
+ */
+function buildQuery(criteria) {
+    if (criteria instanceof Function) {
+        const c = new MysqlCriteria();
+        criteria(c);
+        if (!c.isEmpty()) {
+            return c.generateQuery();
+        }
+    }
+    else if (criteria instanceof MysqlCriteria) {
+        if (!criteria.isEmpty()) {
+            return criteria.generateQuery();
+        }
+    }
+    else {
+        const c = convertToCriteria(criteria);
+        if (!c.isEmpty()) {
+            return c.generateQuery();
+        }
+    }
+    return undefined;
+}
+exports.buildQuery = buildQuery;