wok-server 0.1.0

package/dist/mongodb/manager/base.js

@@ -0,0 +1,563 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMongoManager = void 0;
+const log_1 = require("../../log");
+const validation_1 = require("../../validation");
+const exception_1 = require("../exception");
+/**
+ * mongodb 管理器基类，提供基本的操作功能.
+ */
+class BaseMongoManager {
+    config;
+    db;
+    session;
+    /**
+     * mongodb 管理器构建
+     * @param db 库
+     * @param session 要绑定的会话，用于事务
+     */
+    constructor(config, db, session) {
+        this.config = config;
+        this.db = db;
+        this.session = session;
+    }
+    getCollection(collInfo) {
+        return this.db.collection(collInfo.collectionName);
+    }
+    /**
+     * 查询计时
+     * @param opts
+     */
+    async timingQuery(opts) {
+        const start = new Date().getTime();
+        try {
+            return await opts.query();
+        }
+        finally {
+            if (this.config.slowQueryWarn) {
+                const cost = new Date().getTime() - start;
+                if (cost > this.config.slowQueryMs) {
+                    (0, log_1.getLogger)().warn(`[mongodb slow query] ${cost}ms ${JSON.stringify(opts.desc())}`);
+                }
+            }
+        }
+    }
+    async findById(coll, id) {
+        return this.timingQuery({
+            query: async () => {
+                const res = await this.getCollection(coll).findOne({ _id: id }, {
+                    limit: 1,
+                    session: this.session
+                });
+                return res;
+            },
+            desc: () => ({
+                op: 'findById',
+                coll: coll.collectionName,
+                id
+            })
+        });
+    }
+    /**
+     * 根据id列表查询
+     * @param coll
+     * @param ids
+     * @returns
+     */
+    findByIdIn(coll, ids) {
+        return this.timingQuery({
+            query: async () => {
+                const res = this.getCollection(coll).find({ _id: { $in: ids } }, { session: this.session });
+                return res.toArray();
+            },
+            desc() {
+                return {
+                    op: 'findByIdIn',
+                    coll: coll.collectionName,
+                    ids
+                };
+            }
+        });
+    }
+    /**
+     * 根据id判定是否存在
+     * @param coll
+     * @param id
+     */
+    async existsById(coll, id) {
+        const res = await this.findById(coll, id);
+        return !!res;
+    }
+    /**
+     * 按指定的条件来判定是否存在记录
+     * @param coll
+     * @param filter
+     */
+    async existsBy(coll, filter) {
+        return this.timingQuery({
+            query: async () => {
+                const res = await this.getCollection(coll).findOne(filter, {
+                    limit: 1,
+                    session: this.session
+                });
+                return !!res;
+            },
+            desc() {
+                return {
+                    op: 'existsBy',
+                    coll: coll.collectionName,
+                    filter
+                };
+            }
+        });
+    }
+    /**
+     * 按id进行删除
+     * @param coll
+     * @param id
+     * @returns
+     */
+    async deleteById(coll, id) {
+        return this.timingQuery({
+            query: async () => {
+                const res = await this.getCollection(coll).deleteOne({ _id: id }, {
+                    session: this.session
+                });
+                return res.deletedCount === 1;
+            },
+            desc() {
+                return {
+                    op: 'deleteById',
+                    coll: coll.collectionName,
+                    id
+                };
+            }
+        });
+    }
+    /**
+     * 仅删除一条记录
+     * @param coll
+     * @param filter
+     * @returns
+     */
+    async deleteOne(coll, filter) {
+        if (!Object.keys(filter).length) {
+            throw new exception_1.MongoDBException('filter cannot be empty !');
+        }
+        return this.timingQuery({
+            query: async () => {
+                const res = await this.getCollection(coll).deleteOne(filter, {
+                    session: this.session
+                });
+                return res.deletedCount === 1;
+            },
+            desc() {
+                return {
+                    op: 'deleteMany',
+                    coll: coll.collectionName,
+                    filter
+                };
+            }
+        });
+    }
+    /**
+     * 按条件删除数据，返回删除的记录行数.
+     * 务必谨慎使用，大批量删除容易带来性能问题，造成线上事故.
+     * @param coll
+     * @param filter
+     * @returns 被删除记录的数量
+     */
+    async deleteMany(coll, filter) {
+        if (!Object.keys(filter).length) {
+            throw new exception_1.MongoDBException('filter cannot be empty !');
+        }
+        return this.timingQuery({
+            query: async () => {
+                const res = await this.getCollection(coll).deleteMany(filter, {
+                    session: this.session
+                });
+                return res.deletedCount;
+            },
+            desc() {
+                return {
+                    op: 'deleteMany',
+                    coll: coll.collectionName,
+                    filter
+                };
+            }
+        });
+    }
+    /**
+     * 查询集合中所有记录.谨慎使用！
+     * @param coll
+     * @returns
+     */
+    async findAll(coll) {
+        return this.timingQuery({
+            query: async () => {
+                const arr = await this.getCollection(coll).find({}, { session: this.session }).toArray();
+                return arr;
+            },
+            desc() {
+                return {
+                    op: 'findAll',
+                    coll: coll.collectionName
+                };
+            }
+        });
+    }
+    /**
+     * 根据给定的条件查找第一条符合条件的记录
+     * @param coll
+     * @param filter
+     * @returns
+     */
+    async findFirst(coll, filter) {
+        return this.timingQuery({
+            query: async () => {
+                const res = await this.getCollection(coll).findOne(filter, {
+                    limit: 1,
+                    session: this.session
+                });
+                return res;
+            },
+            desc() {
+                return {
+                    op: 'findFirst',
+                    coll: coll.collectionName,
+                    filter
+                };
+            }
+        });
+    }
+    /**
+     * 插入新记录
+     * @param coll
+     * @param data
+     * @returns
+     */
+    async insert(coll, data) {
+        return this.timingQuery({
+            query: async () => {
+                // 创建时间和更新时间
+                if (coll.createdDate) {
+                    const createdData = coll.createdDate.type === 'date' ? new Date() : new Date().getTime();
+                    data[coll.createdDate.field] = createdData;
+                }
+                if (coll.updatedDate) {
+                    const updatedDate = coll.updatedDate.type === 'date' ? new Date() : new Date().getTime();
+                    data[coll.updatedDate.field] = updatedDate;
+                }
+                const collection = this.getCollection(coll);
+                const res = await collection.insertOne(data, { session: this.session });
+                if (data._id) {
+                    return data;
+                }
+                data._id = res.insertedId;
+                return data;
+            },
+            desc() {
+                return {
+                    op: 'insert',
+                    coll: coll.collectionName,
+                    data
+                };
+            }
+        });
+    }
+    /**
+     * 插入多条，批量插入.
+     * @param coll
+     * @param list
+     */
+    async insertMany(coll, list) {
+        return this.timingQuery({
+            query: async () => {
+                const docList = list.map(data => {
+                    // 创建时间和更新时间
+                    if (coll.createdDate) {
+                        const createdData = coll.createdDate.type === 'date' ? new Date() : new Date().getTime();
+                        data[coll.createdDate.field] = createdData;
+                    }
+                    if (coll.updatedDate) {
+                        const updatedDate = coll.updatedDate.type === 'date' ? new Date() : new Date().getTime();
+                        data[coll.updatedDate.field] = updatedDate;
+                    }
+                    return data;
+                });
+                const collection = this.getCollection(coll);
+                const res = await collection.insertMany(docList, { session: this.session });
+                docList.forEach((doc, idx) => {
+                    if (doc._id) {
+                        return;
+                    }
+                    if (res.insertedIds[idx]) {
+                        doc._id = res.insertedIds[idx];
+                    }
+                });
+                return docList;
+            },
+            desc() {
+                return {
+                    op: 'insertMany',
+                    coll: coll.collectionName,
+                    list
+                };
+            }
+        });
+    }
+    /**
+     * 更新，更新完整的文档内容。
+     * @param coll 集合信息
+     * @param data 要更新的数据，必须包含 _id 字段，支持 mongo 更新语法 $inc 等
+     * @returns 返回最新的数据
+     * @throws MongoDBException 当无法完成更新时抛出
+     */
+    async update(coll, data) {
+        return this.timingQuery({
+            query: async () => {
+                const id = data._id;
+                if (!id) {
+                    throw new exception_1.MongoDBException(`Cannot update a document without an id，collection name：${coll.collectionName}`);
+                }
+                delete data._id;
+                let createData = undefined;
+                // 保护创建时间不被更新
+                if (coll.createdDate && data[coll.createdDate.field]) {
+                    createData = data[coll.createdDate.field];
+                    delete data[coll.createdDate.field];
+                }
+                // 更新时间
+                if (coll.updatedDate) {
+                    const updatedDate = coll.updatedDate.type === 'date' ? new Date() : new Date().getTime();
+                    data[coll.updatedDate.field] = updatedDate;
+                }
+                const res = await this.getCollection(coll).updateOne({ _id: id }, { $set: data }, {
+                    session: this.session
+                });
+                if (res.modifiedCount !== 1) {
+                    throw new exception_1.MongoDBException(`Failed to update record, possibly due to non-existent record，collection：${coll.collectionName}，id：${id}`);
+                }
+                data._id = id;
+                if (coll.createdDate && createData) {
+                    data[coll.createdDate.field] = createData;
+                }
+                return data;
+            },
+            desc() {
+                return {
+                    op: 'update',
+                    coll: coll.collectionName,
+                    data
+                };
+            }
+        });
+    }
+    /**
+     * 仅更新一条记录
+     * @param coll
+     * @param filter
+     * @param updater
+     */
+    async updateOne(coll, filter, updater) {
+        if (!Object.keys(filter).length) {
+            throw new exception_1.MongoDBException('filter cannot be empty !');
+        }
+        if (!Object.keys(updater).length) {
+            throw new exception_1.MongoDBException('updater cannot be empty !');
+        }
+        return this.timingQuery({
+            query: async () => {
+                // 更新时间处理
+                if (coll.updatedDate) {
+                    const updatedDate = coll.updatedDate.type === 'date' ? new Date() : new Date().getTime();
+                    if (updater.$set) {
+                        updater.$set[coll.updatedDate.field] = updatedDate;
+                    }
+                    else {
+                        updater.$set = { [coll.updatedDate.field]: updatedDate };
+                    }
+                }
+                const res = await this.getCollection(coll).updateOne(filter, updater, {
+                    session: this.session
+                });
+                return res.modifiedCount === 1;
+            },
+            desc() {
+                return {
+                    op: 'updateOne',
+                    coll: coll.collectionName,
+                    filter,
+                    updator: updater
+                };
+            }
+        });
+    }
+    /**
+     * 局部更新，仅更新部分字段，可对字段做递增或数组元组的处理。
+     * @param coll 集合信息
+     * @param id id
+     * @param updater 更新内容
+     * @returns 更新是否成功
+     */
+    async partialUpdate(coll, id, updater) {
+        if (!Object.keys(updater).length) {
+            throw new exception_1.MongoDBException('updater cannot be empty !');
+        }
+        return this.timingQuery({
+            query: async () => {
+                // 更新时间处理
+                if (coll.updatedDate) {
+                    const updatedDate = coll.updatedDate.type === 'date' ? new Date() : new Date().getTime();
+                    if (updater.$set) {
+                        updater.$set[coll.updatedDate.field] = updatedDate;
+                    }
+                    else {
+                        updater.$set = { [coll.updatedDate.field]: updatedDate };
+                    }
+                }
+                const res = await this.getCollection(coll).updateOne({ _id: id }, updater, {
+                    session: this.session
+                });
+                return res.modifiedCount === 1;
+            },
+            desc() {
+                return {
+                    op: 'partialUpdate',
+                    coll: coll.collectionName,
+                    id,
+                    updator: updater
+                };
+            }
+        });
+    }
+    /**
+     * 根据条件更新多条记录，和 partialUpdate 区别是可以根据过滤条件来处理多条记录。
+     * @param coll 集合
+     * @param filter 过滤规则
+     * @param updater 更新内容
+     * @returns 此次更新的记录数
+     */
+    async updateMany(coll, filter, updater) {
+        if (!Object.keys(filter).length) {
+            throw new exception_1.MongoDBException('filter cannot be empty !');
+        }
+        if (!Object.keys(updater).length) {
+            throw new exception_1.MongoDBException('updater cannot be empty !');
+        }
+        return this.timingQuery({
+            query: async () => {
+                // 更新时间处理
+                if (coll.updatedDate) {
+                    const updatedDate = coll.updatedDate.type === 'date' ? new Date() : new Date().getTime();
+                    if (updater.$set) {
+                        updater.$set[coll.updatedDate.field] = updatedDate;
+                    }
+                    else {
+                        updater.$set = { [coll.updatedDate.field]: updatedDate };
+                    }
+                }
+                const res = await this.getCollection(coll).updateMany(filter, updater, {
+                    session: this.session
+                });
+                return res.modifiedCount;
+            },
+            desc() {
+                return {
+                    op: 'updateMany',
+                    coll: coll.collectionName,
+                    filter,
+                    updator: updater
+                };
+            }
+        });
+    }
+    /**
+     * 条件查询
+     * @param coll 集合信息
+     * @param filter 过滤条件
+     * @param opts 额外的选项
+     * @returns
+     */
+    async find(coll, filter, opts) {
+        return this.timingQuery({
+            query: async () => {
+                const arr = await this.getCollection(coll)
+                    .find(filter, {
+                    limit: opts && opts.limit && opts.limit > 0 ? opts.limit : undefined,
+                    skip: opts && opts.limit && opts.limit > 0 && opts.offset && opts.offset > 0
+                        ? opts.offset
+                        : undefined,
+                    sort: opts && opts.orderBy ? opts.orderBy : undefined,
+                    session: this.session
+                })
+                    .toArray();
+                return arr;
+            },
+            desc() {
+                return {
+                    op: 'find',
+                    coll: coll.collectionName,
+                    filter,
+                    opts
+                };
+            }
+        });
+    }
+    /**
+     * 查询符合条件的文档数量。请谨慎使用，count 是不能从索引直接读取的，只能实时计数，使用不当容易造成性能问题，引发线上事故。
+     * @param coll
+     * @param filter
+     * @returns
+     */
+    count(coll, filter) {
+        return this.timingQuery({
+            query: async () => {
+                return this.getCollection(coll).countDocuments(filter, { session: this.session });
+            },
+            desc() {
+                return {
+                    op: 'count',
+                    coll: coll.collectionName,
+                    filter
+                };
+            }
+        });
+    }
+    /**
+     * 分页查询。谨慎使用，不建议对规模较大的数据查询直接使用分页。
+     * @param coll 集合信息
+     * @param filter 过滤条件
+     * @param opts 分页参数
+     */
+    async paginate(coll, filter, opts) {
+        (0, validation_1.validate)(opts, {
+            pn: [(0, validation_1.notNull)(), (0, validation_1.min)(1)],
+            pz: [(0, validation_1.notNull)(), (0, validation_1.min)(1)]
+        });
+        const start = new Date().getTime();
+        try {
+            const offset = (opts.pn - 1) * opts.pz;
+            const res = await Promise.all([
+                this.find(coll, filter, { offset, limit: opts.pz, orderBy: opts.orderBy }),
+                this.count(coll, filter)
+            ]);
+            const [list, total] = res;
+            return { list, total };
+        }
+        finally {
+            if (this.config.slowQueryWarn) {
+                const cost = new Date().getTime() - start;
+                if (cost > this.config.slowQueryMs) {
+                    (0, log_1.getLogger)().warn(`[mongodb slow query] ${cost}ms ${JSON.stringify({
+                        op: 'paginate',
+                        coll: coll.collectionName,
+                        filter,
+                        opts
+                    })}`);
+                }
+            }
+        }
+    }
+}
+exports.BaseMongoManager = BaseMongoManager;

package/dist/mongodb/manager/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoTxSession = exports.BaseMongoManager = exports.MongoDBManager = void 0;
+const exception_1 = require("../exception");
+const base_1 = require("./base");
+Object.defineProperty(exports, "BaseMongoManager", { enumerable: true, get: function () { return base_1.BaseMongoManager; } });
+const tx_1 = require("./tx");
+Object.defineProperty(exports, "MongoTxSession", { enumerable: true, get: function () { return tx_1.MongoTxSession; } });
+const tx_strict_1 = require("./tx-strict");
+/**
+ * mongodb 管理器，目前尚未实现事务的处理.
+ */
+class MongoDBManager extends base_1.BaseMongoManager {
+    client;
+    /**
+     * mongodb 管理器构建
+     * @param db 库
+     */
+    constructor(config, db, client) {
+        super(config, db);
+        this.client = client;
+    }
+    /**
+     * 事务操作。mongodb 的版本必须在 4.0 以上，连接的必须是副本集节点或分片集群的mongos节点。
+     * @param ops 操作逻辑，所有事务相关的操作都必须使用函数提供的 session 对象
+     * @param opts mongo 事务选项
+     */
+    async tx(ops, opts) {
+        const timeout = opts && typeof opts.timeout === 'number' ? opts.timeout : this.config.transactionTimeout;
+        const nativeSession = this.client.startSession();
+        nativeSession.startTransaction(opts);
+        const txSesssion = this.config.transactionStrict
+            ? new tx_strict_1.MongoStrictTxSession(this.config, this.db, nativeSession)
+            : new tx_1.MongoTxSession(this.config, this.db, nativeSession);
+        try {
+            const result = timeout > 0
+                ? await Promise.race([
+                    ops(txSesssion),
+                    new Promise((resolve, reject) => {
+                        setTimeout(() => {
+                            // 立即中止会话，防止再有后续操作
+                            txSesssion.abort();
+                            reject(new exception_1.MongoDBException('Transaction timeout !'));
+                        }, timeout);
+                    })
+                ])
+                : await ops(txSesssion);
+            await nativeSession.commitTransaction();
+            return result;
+        }
+        catch (error) {
+            await nativeSession.abortTransaction();
+            // 将原错误抛出，如果有需要，调用处可对异常做进一步的处理
+            throw error;
+        }
+        finally {
+            // 无论如何中止会话，离开事务，会话就不能再被使用
+            txSesssion.abort();
+            await nativeSession.endSession();
+        }
+    }
+}
+exports.MongoDBManager = MongoDBManager;

package/dist/mongodb/manager/tx-strict.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoStrictTxSession = void 0;
+const exception_1 = require("../exception");
+const tx_1 = require("./tx");
+/**
+ * 严格事务会话
+ */
+class MongoStrictTxSession extends tx_1.MongoTxSession {
+    #opsCount = 0;
+    constructor(config, db, session) {
+        super(config, db, session);
+    }
+    /**
+     * 为操作计数，检查是否操作次数过多.
+     */
+    #checkAndAddOpsCount() {
+        if (this.#opsCount >= 10) {
+            throw new exception_1.MongoDBException('Too many operations in a strict transaction.');
+        }
+        this.#opsCount++;
+    }
+    findById(coll, id) {
+        this.#checkAndAddOpsCount();
+        return super.findById(coll, id);
+    }
+    findByIdIn(coll, ids) {
+        if (ids.length > 100) {
+            throw new exception_1.MongoDBException(`The augument ids length(${ids.length}) passed to findByIdIn in a strict transaction is too large .`);
+        }
+        this.#checkAndAddOpsCount();
+        return super.findByIdIn(coll, ids);
+    }
+    existsBy(coll, filter) {
+        this.#checkAndAddOpsCount();
+        return super.existsBy(coll, filter);
+    }
+    deleteById(coll, id) {
+        this.#checkAndAddOpsCount();
+        return super.deleteById(coll, id);
+    }
+    deleteOne(coll, filter) {
+        this.#checkAndAddOpsCount();
+        return super.deleteOne(coll, filter);
+    }
+    deleteMany(coll, filter) {
+        throw new exception_1.MongoDBException('Prohibited to use deleteMany in a strict transaction.');
+    }
+    findAll(coll) {
+        throw new exception_1.MongoDBException('Prohibited to use findAll in a strict transaction.');
+    }
+    findFirst(coll, filter) {
+        this.#checkAndAddOpsCount();
+        return super.findFirst(coll, filter);
+    }
+    insert(coll, data) {
+        this.#checkAndAddOpsCount();
+        return super.insert(coll, data);
+    }
+    insertMany(coll, list) {
+        throw new exception_1.MongoDBException('Prohibited to use insertMany in a strict transaction.');
+    }
+    update(coll, data) {
+        this.#checkAndAddOpsCount();
+        return super.update(coll, data);
+    }
+    partialUpdate(coll, id, updator) {
+        this.#checkAndAddOpsCount();
+        return super.partialUpdate(coll, id, updator);
+    }
+    updateMany(coll, filter, updator) {
+        throw new exception_1.MongoDBException('Prohibited to use updateMany in a strict transaction.');
+    }
+    find(coll, filter, opts) {
+        throw new exception_1.MongoDBException('Prohibited to use find in a strict transaction.');
+    }
+    count(coll, filter) {
+        throw new exception_1.MongoDBException('Prohibited to use count in a strict transaction.');
+    }
+    paginate(coll, filter, opts) {
+        throw new exception_1.MongoDBException('Prohibited to use paginate in a strict transaction.');
+    }
+}
+exports.MongoStrictTxSession = MongoStrictTxSession;