@midwayjs/tags 3.0.0

package/README.md

@@ -0,0 +1,9 @@
+# midway-tags
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -0,0 +1,4 @@
+export declare class TagsConfiguration {
+    onReady(container: any): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagsConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const manager_1 = require("./manager");
+let TagsConfiguration = class TagsConfiguration {
+    async onReady(container) {
+        await container.getAsync(manager_1.TagServiceFactory);
+    }
+};
+TagsConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'tags',
+        importConfigs: [
+            {
+                default: {
+                    tags: {
+                        default: {
+                            dialectType: 'memory',
+                        },
+                    },
+                },
+            },
+        ],
+    })
+], TagsConfiguration);
+exports.TagsConfiguration = TagsConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/dialect/index.d.ts

@@ -0,0 +1,3 @@
+export * from './memory';
+export * from './mysql';
+//# sourceMappingURL=index.d.ts.map

package/dist/dialect/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./memory"), exports);
+__exportStar(require("./mysql"), exports);
+//# sourceMappingURL=index.js.map

package/dist/dialect/memory.d.ts

@@ -0,0 +1,27 @@
+import { ITagDialectInstance } from '..';
+import { ITagBindOptions, ITagDefine, ITagDialect, ITagItem, ITagListInstanceOptions, ITagListInstanceTagsOptions, ITagListResult, ITagOperResult, ITagSearchOptions, ITagUnBindOptions } from '../interface';
+interface MemoryInstanceStore {
+    tagStore: Map<string | number, ITagItem>;
+    tagRelationStore: Map<`${number}-${number}`, boolean>;
+}
+export declare class MemoryDialect implements ITagDialect {
+    private tagStore;
+    ready(): Promise<void>;
+    getInstance(group: string): ITagDialectInstance;
+}
+export declare class MemoryDialectInstance implements ITagDialectInstance {
+    private tagIndex;
+    private tagStore;
+    private tagRelationStore;
+    constructor(stores: MemoryInstanceStore);
+    new(tagDefine: ITagDefine): Promise<ITagOperResult>;
+    remove(tagIdOrName: number): Promise<ITagOperResult>;
+    update(tagIdOrName: number, params: Partial<ITagDefine>): Promise<ITagOperResult>;
+    list(listOptions?: ITagSearchOptions): Promise<ITagListResult<ITagItem>>;
+    bind(bindOptions?: ITagBindOptions): Promise<ITagOperResult>;
+    unbind(unbindOptions: ITagUnBindOptions): Promise<ITagOperResult>;
+    listObjects(listOptions?: ITagListInstanceOptions): Promise<ITagListResult<number>>;
+    listObjectTags(listOptions?: ITagListInstanceTagsOptions): Promise<ITagListResult<ITagItem>>;
+}
+export {};
+//# sourceMappingURL=memory.d.ts.map

package/dist/dialect/memory.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDialectInstance = exports.MemoryDialect = void 0;
+const error_1 = require("../error");
+const interface_1 = require("../interface");
+const utils_1 = require("../utils");
+class MemoryDialect {
+    constructor() {
+        // store tag information
+        this.tagStore = new Map();
+    }
+    async ready() { }
+    getInstance(group) {
+        let instanceStores = this.tagStore.get(group);
+        if (!instanceStores) {
+            instanceStores = {
+                tagStore: new Map(),
+                tagRelationStore: new Map(),
+            };
+            this.tagStore.set(group, instanceStores);
+        }
+        return new MemoryDialectInstance(instanceStores);
+    }
+}
+exports.MemoryDialect = MemoryDialect;
+class MemoryDialectInstance {
+    constructor(stores) {
+        this.tagIndex = 0;
+        this.tagStore = stores.tagStore;
+        this.tagRelationStore = stores.tagRelationStore;
+    }
+    async new(tagDefine) {
+        const existTagItem = this.tagStore.get(tagDefine.name);
+        if (existTagItem) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.EXISTS, {
+                id: existTagItem.id,
+            });
+        }
+        const tagId = ++this.tagIndex;
+        const tagItem = {
+            ...tagDefine,
+            id: tagId,
+            createAt: Date.now(),
+            updateAt: Date.now(),
+        };
+        this.tagStore.set(tagId, tagItem);
+        this.tagStore.set(tagItem.name, tagItem);
+        return (0, utils_1.success)({
+            id: tagId,
+        });
+    }
+    async remove(tagIdOrName) {
+        const tagItem = this.tagStore.get(tagIdOrName);
+        if (!tagItem) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, { id: tagIdOrName });
+        }
+        const { list: allObjectId } = await this.listObjects({
+            tags: [tagItem.id],
+            pageSize: Infinity,
+        });
+        for (const objectId of allObjectId) {
+            this.tagRelationStore.delete(`${tagItem.id}-${objectId}`);
+        }
+        this.tagStore.delete(tagItem.name);
+        this.tagStore.delete(tagItem.id);
+        return (0, utils_1.success)({ id: tagItem.id });
+    }
+    async update(tagIdOrName, params) {
+        const tagItem = this.tagStore.get(tagIdOrName);
+        if (!tagItem) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, { id: tagIdOrName });
+        }
+        Object.assign(tagItem, {
+            ...params,
+            id: tagItem.id,
+        });
+        return (0, utils_1.success)({ id: tagItem.id });
+    }
+    async list(listOptions) {
+        const { page, pageSize, tags = [], count } = listOptions;
+        const { limit: start, end } = (0, utils_1.getPageOpions)(page, pageSize);
+        let matchedItemIndex = 0;
+        const result = [];
+        for (let i = 0; i <= this.tagIndex; i++) {
+            const tagItem = this.tagStore.get(i);
+            if (!tagItem) {
+                continue;
+            }
+            const matched = tags.length
+                ? !!tags.find(matchItem => {
+                    if (typeof matchItem === 'string') {
+                        const { matchStart, matchEnd, text } = (0, utils_1.formatMatchLike)(matchItem);
+                        if (matchEnd && matchStart) {
+                            return tagItem.name.includes(text);
+                        }
+                        else if (matchStart) {
+                            return tagItem.name.startsWith(text);
+                        }
+                        else if (matchEnd) {
+                            return tagItem.name.endsWith(text);
+                        }
+                        else {
+                            return tagItem.name === text;
+                        }
+                    }
+                    return tagItem.id === matchItem;
+                })
+                : true;
+            if (matched) {
+                if (matchedItemIndex >= start && matchedItemIndex < end) {
+                    result.push(tagItem);
+                    if (!count && result.length === pageSize) {
+                        break;
+                    }
+                }
+                matchedItemIndex++;
+            }
+        }
+        const returnResult = {
+            list: result,
+        };
+        if (count) {
+            returnResult.total = matchedItemIndex;
+        }
+        return returnResult;
+    }
+    async bind(bindOptions) {
+        let tagList = [];
+        try {
+            tagList = await Promise.all(bindOptions.tags.map(async (tag) => {
+                let tagItem = this.tagStore.get(tag);
+                if (!tagItem) {
+                    if (typeof tag === 'string' && bindOptions.autoCreateTag) {
+                        const newTag = await this.new({
+                            name: tag,
+                            desc: 'auto create',
+                        });
+                        tagItem = this.tagStore.get(newTag.id);
+                    }
+                    else {
+                        throw (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, { id: [tag] });
+                    }
+                }
+                return tagItem;
+            }));
+        }
+        catch (e) {
+            return e;
+        }
+        for (const tagItem of tagList) {
+            this.tagRelationStore.set(`${tagItem.id}-${bindOptions.objectId}`, true);
+        }
+        return (0, utils_1.success)();
+    }
+    async unbind(unbindOptions) {
+        for (const tag of unbindOptions.tags) {
+            const tagItem = this.tagStore.get(tag);
+            if (tagItem) {
+                this.tagRelationStore.delete(`${tagItem.id}-${unbindOptions.objectId}`);
+            }
+        }
+        return (0, utils_1.success)();
+    }
+    async listObjects(listOptions) {
+        const { page, pageSize, tags = [], count, type = interface_1.MATCH_TYPE.Or, } = listOptions;
+        const { limit: start, end } = (0, utils_1.getPageOpions)(page, pageSize);
+        let matchedItemIndex = 0;
+        const result = [];
+        const resultIdMap = {};
+        for (const [relative] of this.tagRelationStore) {
+            const [tagId, relaObjectId] = relative.split('-');
+            if (resultIdMap[relaObjectId] &&
+                resultIdMap[relaObjectId].length === tags.length) {
+                continue;
+            }
+            const tagItem = this.tagStore.get(+tagId);
+            if (!tagItem) {
+                continue;
+            }
+            const matched = tags.length
+                ? !!tags.find(matchItem => {
+                    if (typeof matchItem === 'string') {
+                        return tagItem.name === matchItem;
+                    }
+                    return tagItem.id === matchItem;
+                })
+                : true;
+            if (matched) {
+                if (!resultIdMap[relaObjectId]) {
+                    resultIdMap[relaObjectId] = [];
+                }
+                resultIdMap[relaObjectId].push(tagItem.id);
+                if ((type === interface_1.MATCH_TYPE.And &&
+                    resultIdMap[relaObjectId].length === tags.length) ||
+                    (type === interface_1.MATCH_TYPE.Or && resultIdMap[relaObjectId].length === 1)) {
+                    if (matchedItemIndex >= start && matchedItemIndex < end) {
+                        result.push(+relaObjectId);
+                    }
+                    matchedItemIndex++;
+                }
+                if (!count && result.length === pageSize) {
+                    break;
+                }
+            }
+        }
+        const returnResult = {
+            list: result,
+        };
+        if (count) {
+            returnResult.total = matchedItemIndex;
+        }
+        return returnResult;
+    }
+    async listObjectTags(listOptions) {
+        const { page, pageSize, objectId, count } = listOptions;
+        const { limit: start, end } = (0, utils_1.getPageOpions)(page, pageSize);
+        let matchedItemIndex = 0;
+        const result = [];
+        const resultIdMap = {};
+        for (const [relative] of this.tagRelationStore) {
+            const [tagId, relaObjectId] = relative.split('-');
+            if (+relaObjectId !== objectId) {
+                continue;
+            }
+            const tagItem = this.tagStore.get(+tagId);
+            if (!tagItem || resultIdMap[tagId]) {
+                continue;
+            }
+            resultIdMap[tagId] = true;
+            if (matchedItemIndex >= start && matchedItemIndex < end) {
+                result.push(tagItem);
+            }
+            matchedItemIndex++;
+        }
+        const returnResult = {
+            list: result,
+        };
+        if (count) {
+            returnResult.total = matchedItemIndex;
+        }
+        return returnResult;
+    }
+}
+exports.MemoryDialectInstance = MemoryDialectInstance;
+//# sourceMappingURL=memory.js.map

package/dist/dialect/mysql.d.ts

@@ -0,0 +1,38 @@
+import { IMysqlQuery, ITagBindOptions, ITagDefine, ITagDialect, ITagDialectInstance, ITagItem, ITagListInstanceOptions, ITagListInstanceTagsOptions, ITagListResult, ITagMysqlDialectOption, ITagOperResult, ITagSearchOptions, ITagUnBindOptions } from '../interface';
+export declare enum MysqlTableName {
+    Tag = "tag",
+    Relationship = "relationship"
+}
+export declare class MysqlDialect implements ITagDialect {
+    private dialectOptions;
+    private name;
+    private query;
+    constructor(dialect: ITagMysqlDialectOption);
+    ready(): Promise<void>;
+    getInstance(group: string): ITagDialectInstance;
+    private buildTableName;
+    private syncTable;
+    private checkOrCreateTable;
+}
+interface MysqlDialectInstanceOptions {
+    group: string;
+    getTableName: (str: string) => string;
+    query: IMysqlQuery;
+}
+export declare class MysqlDialectInstance implements ITagDialectInstance {
+    private group;
+    private query;
+    private buildTableName;
+    constructor(options: MysqlDialectInstanceOptions);
+    new(tagDefine: ITagDefine): Promise<ITagOperResult>;
+    remove(tagIdOrName: number): Promise<ITagOperResult>;
+    update(tagIdOrName: number, params: Partial<ITagDefine>): Promise<ITagOperResult>;
+    list(listOptions?: ITagSearchOptions): Promise<ITagListResult<ITagItem>>;
+    bind(bindOptions?: ITagBindOptions): Promise<ITagOperResult>;
+    unbind(unbindOptions: ITagUnBindOptions): Promise<ITagOperResult>;
+    listObjects(listOptions?: ITagListInstanceOptions): Promise<ITagListResult<number>>;
+    listObjectTags(listOptions?: ITagListInstanceTagsOptions): Promise<ITagListResult<ITagItem>>;
+    private getTags;
+}
+export {};
+//# sourceMappingURL=mysql.d.ts.map

package/dist/dialect/mysql.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlDialectInstance = exports.MysqlDialect = exports.MysqlTableName = void 0;
+const error_1 = require("../error");
+const interface_1 = require("../interface");
+const utils_1 = require("../utils");
+var MysqlTableName;
+(function (MysqlTableName) {
+    MysqlTableName["Tag"] = "tag";
+    MysqlTableName["Relationship"] = "relationship";
+})(MysqlTableName = exports.MysqlTableName || (exports.MysqlTableName = {}));
+class MysqlDialect {
+    constructor(dialect) {
+        this.name = 'tags';
+        this.dialectOptions = dialect;
+        this.query = this.dialectOptions.instance.query;
+    }
+    async ready() {
+        if (this.dialectOptions.sync) {
+            await this.syncTable();
+        }
+    }
+    getInstance(group) {
+        return new MysqlDialectInstance({
+            group,
+            query: this.dialectOptions.instance.query,
+            getTableName: this.buildTableName.bind(this),
+        });
+    }
+    buildTableName(tableName) {
+        const tableNameList = this.dialectOptions.tablePrefix
+            ? [this.dialectOptions.tablePrefix, this.name]
+            : [this.name];
+        return tableNameList
+            .concat(tableName)
+            .join(this.dialectOptions.tableSeparator || '_');
+    }
+    async syncTable() {
+        // tag table
+        await this.checkOrCreateTable(this.buildTableName(MysqlTableName.Tag), [
+            '`group` varchar(32) NULL,',
+            '`name` varchar(32) NULL,',
+            '`descri` varchar(128) NULL,',
+        ]);
+        // relationship table
+        await this.checkOrCreateTable(this.buildTableName(MysqlTableName.Relationship), ['`tid` BIGINT unsigned NOT NULL,', '`oid` BIGINT unsigned NOT NULL,']);
+    }
+    async checkOrCreateTable(tableName, tableColumn) {
+        const [raws] = await this.query(`SHOW TABLES LIKE '${tableName}'`);
+        if (raws.length) {
+            return;
+        }
+        const createSql = `CREATE TABLE \`${tableName}\` (
+      \`id\` BIGINT unsigned NOT NULL AUTO_INCREMENT,
+      ${tableColumn.join('\n')}
+      \`created_at\` TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+      \`update_at\` TIMESTAMP DEFAULT CURRENT_TIMESTAMP  ON UPDATE CURRENT_TIMESTAMP NOT NULL,
+      PRIMARY KEY (id)
+    );`;
+        await this.query(createSql);
+    }
+}
+exports.MysqlDialect = MysqlDialect;
+class MysqlDialectInstance {
+    constructor(options) {
+        this.group = options.group;
+        this.query = options.query;
+        this.buildTableName = options.getTableName;
+    }
+    async new(tagDefine) {
+        const { ids: [existTagId], } = await this.getTags(tagDefine.name);
+        if (existTagId) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.EXISTS, {
+                id: existTagId,
+            });
+        }
+        const sql = `insert into ${this.buildTableName(MysqlTableName.Tag)} (\`group\`, \`name\`, \`descri\`) values (?, ?, ?)`;
+        const [raws] = await this.query(sql, [
+            this.group,
+            tagDefine.name,
+            tagDefine.desc,
+        ]);
+        if (!raws.insertId) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.OPER_ERROR);
+        }
+        return (0, utils_1.success)({
+            id: raws.insertId,
+        });
+    }
+    async remove(tagIdOrName) {
+        const { ids: [existTagId], } = await this.getTags(tagIdOrName);
+        if (!existTagId) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, { id: tagIdOrName });
+        }
+        // 先删除 object tag，
+        const removeRelationshipSql = `delete from ${this.buildTableName(MysqlTableName.Relationship)} where tid = ${existTagId}`;
+        await this.query(removeRelationshipSql);
+        const sql = `delete from ${this.buildTableName(MysqlTableName.Tag)} where id = ${existTagId}`;
+        const [raws] = await this.query(sql);
+        if (raws.affectedRows !== 1) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.OPER_ERROR);
+        }
+        return (0, utils_1.success)({ id: existTagId });
+    }
+    async update(tagIdOrName, params) {
+        const { ids: [existTagId], } = await this.getTags(tagIdOrName);
+        if (!existTagId) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, { id: tagIdOrName });
+        }
+        const fields = [];
+        const placeholders = [];
+        Object.keys(params).forEach(key => {
+            if (key === 'group' || key === 'id') {
+                return;
+            }
+            let updateKey = key;
+            if (key === 'desc') {
+                updateKey = 'descri';
+            }
+            fields.push(`\`${updateKey}\` = ?`);
+            placeholders.push(params[key]);
+        });
+        const sql = `update ${this.buildTableName(MysqlTableName.Tag)} set ${fields.join(', ')} where id = ${existTagId}`;
+        const [raws] = await this.query(sql, placeholders);
+        if (raws.affectedRows !== 1) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.OPER_ERROR);
+        }
+        return (0, utils_1.success)({
+            id: existTagId,
+        });
+    }
+    async list(listOptions) {
+        const { page, pageSize, tags = [], count } = listOptions;
+        const { limit, offset } = (0, utils_1.getPageOpions)(page, pageSize);
+        const idList = [];
+        const nameList = [];
+        const placeholder = [this.group];
+        for (const matchItem of tags) {
+            if (typeof matchItem === 'number') {
+                idList.push(matchItem);
+            }
+            else if (typeof matchItem === 'string') {
+                nameList.push(matchItem);
+            }
+        }
+        const condition = [
+            idList.length ? `id in (${idList.join()})` : '',
+            ...nameList.map((name) => {
+                const { matchStart, matchEnd, text } = (0, utils_1.formatMatchLike)(name);
+                if (matchStart && matchEnd) {
+                    placeholder.push(text);
+                    return '`name` = ?';
+                }
+                placeholder.push(name);
+                return '`name` like ?';
+            }),
+        ]
+            .filter(v => !!v)
+            .join(' or ');
+        const selectSql = `select * from ${this.buildTableName(MysqlTableName.Tag)} where \`group\` = ?${condition ? ` and (${condition})` : ''} limit ${limit},${offset}`;
+        const queryPromise = [this.query(selectSql, placeholder)];
+        if (count) {
+            const countSql = `select count(id) as total from ${this.buildTableName(MysqlTableName.Tag)} where \`group\` = ?${condition ? ` and (${condition})` : ''}`;
+            queryPromise.push(this.query(countSql, placeholder));
+        }
+        const [selectRes, countRes] = await Promise.all(queryPromise).then(resultList => {
+            return resultList.map(([raws]) => {
+                return raws;
+            });
+        });
+        const returnResult = {
+            list: selectRes.map(item => {
+                item.desc = item.descri;
+                delete item.descri;
+                return item;
+            }),
+        };
+        if (count) {
+            returnResult.total = countRes[0].total;
+        }
+        return returnResult;
+    }
+    async bind(bindOptions) {
+        const { tags, objectId, autoCreateTag } = bindOptions;
+        const { ids, notExists } = await this.getTags(tags);
+        if (notExists.id.length) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, {
+                id: notExists.id,
+            });
+        }
+        if (notExists.name.length) {
+            if (!autoCreateTag) {
+                return (0, utils_1.error)(error_1.TAG_ERROR.NOT_EXISTS, {
+                    id: notExists.name,
+                });
+            }
+            const newTagIds = await Promise.all(notExists.name.map(async (tag) => {
+                const { id } = await this.new({
+                    name: tag,
+                    desc: 'auto creat',
+                });
+                return id;
+            }));
+            ids.push(...newTagIds);
+        }
+        await Promise.all(ids.map(async (tagId) => {
+            // TODO: 简单事务，检测是否存在关系
+            await this.query(`insert into ${this.buildTableName(MysqlTableName.Relationship)} (\`tid\`, \`oid\`) values (?, ?)`, [tagId, objectId]);
+        }));
+        return (0, utils_1.success)();
+    }
+    async unbind(unbindOptions) {
+        var _a;
+        let removeRelationshipSql = `delete from ${this.buildTableName(MysqlTableName.Relationship)} where oid = ${unbindOptions.objectId}`;
+        if ((_a = unbindOptions.tags) === null || _a === void 0 ? void 0 : _a.length) {
+            const { ids } = await this.getTags(unbindOptions.tags);
+            removeRelationshipSql += ` and tid in (${ids.join(',')})`;
+        }
+        await this.query(removeRelationshipSql);
+        return (0, utils_1.success)();
+    }
+    async listObjects(listOptions) {
+        const { page, pageSize, tags = [], count, type = interface_1.MATCH_TYPE.Or, } = listOptions;
+        const { limit, offset } = (0, utils_1.getPageOpions)(page, pageSize);
+        const { ids, notExists } = await this.getTags(tags);
+        if (notExists.all.length) {
+            return {
+                list: [],
+                total: 0,
+            };
+        }
+        let sql = '';
+        let countSql = '';
+        if (tags.length === 1) {
+            // for more high performance
+            const sqlBase = `FROM ${this.buildTableName(MysqlTableName.Relationship)} where tid = ${ids[0]}`;
+            sql = `SELECT oid ${sqlBase} limit ${limit},${offset}`;
+            countSql = `SELECT count(*) as total ${sqlBase}`;
+        }
+        else {
+            if (type === interface_1.MATCH_TYPE.Or) {
+                const sqlBase = `FROM ${this.buildTableName(MysqlTableName.Relationship)} where tid in (${ids.join(',')})`;
+                sql = `SELECT distinct oid ${sqlBase} limit ${limit},${offset}`;
+                countSql = `SELECT count(distinct oid) as total ${sqlBase}`;
+            }
+            else if (type === interface_1.MATCH_TYPE.And) {
+                sql = `SELECT oid FROM ${this.buildTableName(MysqlTableName.Relationship)} where tid in (${ids.join(',')}) group by oid HAVING COUNT(*) = ${ids.length} limit ${limit},${offset}`;
+                countSql = `SELECT count(*) as total FROM (SELECT oid FROM ${this.buildTableName(MysqlTableName.Relationship)} where tid in (${ids.join(',')}) group by oid HAVING COUNT(*) = ${ids.length}) as list`;
+            }
+        }
+        const queryPromises = [];
+        queryPromises.push(this.query(sql));
+        if (count) {
+            queryPromises.push(this.query(countSql));
+        }
+        const [selectRes, countRes] = await Promise.all(queryPromises).then(resultList => {
+            return resultList.map(([raws]) => {
+                return raws;
+            });
+        });
+        const returnResult = {
+            list: selectRes.map(item => {
+                return item.oid;
+            }),
+        };
+        if (count) {
+            returnResult.total = countRes[0].total;
+        }
+        return returnResult;
+    }
+    async listObjectTags(listOptions) {
+        const { page, pageSize, objectId, count } = listOptions;
+        const { limit, offset } = (0, utils_1.getPageOpions)(page, pageSize);
+        const sql = `select tid from ${this.buildTableName(MysqlTableName.Relationship)} where oid = ? limit ${limit},${offset}`;
+        const queryPromises = [this.query(sql, [objectId])];
+        if (count) {
+            const sql = `select count(tid) as total from ${this.buildTableName(MysqlTableName.Relationship)} where oid = ?`;
+            queryPromises.push(this.query(sql, [objectId]));
+        }
+        const [tagIdList, countRes] = await Promise.all(queryPromises).then(resultList => {
+            return resultList.map(([raws]) => {
+                return raws;
+            });
+        });
+        let tagList = [];
+        if (tagIdList.length) {
+            const { list } = await this.list({
+                tags: tagIdList.map(raw => raw.tid),
+            });
+            tagList = list;
+        }
+        const returnResult = {
+            list: tagList,
+        };
+        if (count) {
+            returnResult.total = countRes[0].total;
+        }
+        return returnResult;
+    }
+    async getTags(tagIdOrName) {
+        const tags = [].concat(tagIdOrName);
+        const idList = [];
+        const nameList = [];
+        const placeholder = [this.group];
+        const keyMap = new Map();
+        for (const tag of tags) {
+            keyMap.set(tag, true);
+            if (typeof tag === 'number') {
+                idList.push(tag);
+            }
+            else if (typeof tag === 'string') {
+                nameList.push('`name` = ?');
+                placeholder.push(tag);
+            }
+        }
+        const condition = [
+            idList.length ? `id in (${idList.join()})` : '',
+            ...nameList,
+        ]
+            .filter(v => !!v)
+            .join(' or ');
+        const sql = `select id,name from ${this.buildTableName(MysqlTableName.Tag)} where \`group\` = ?${condition ? ` and (${condition})` : ''}`;
+        const [raws] = await this.query(sql, placeholder);
+        const tagIds = raws.map(raw => {
+            keyMap.delete(raw.id);
+            keyMap.delete(raw.name);
+            return raw.id;
+        });
+        const notExists = {
+            id: [],
+            name: [],
+            all: [],
+        };
+        const notExistKeys = keyMap.keys();
+        for (const key of notExistKeys) {
+            notExists.all.push(key);
+            if (typeof key === 'number') {
+                notExists.id.push(key);
+            }
+            else if (typeof key === 'string') {
+                notExists.name.push(key);
+            }
+        }
+        notExists.all;
+        return {
+            ids: tagIds,
+            notExists,
+        };
+    }
+}
+exports.MysqlDialectInstance = MysqlDialectInstance;
+//# sourceMappingURL=mysql.js.map

package/dist/error.d.ts

@@ -0,0 +1,7 @@
+export declare enum TAG_ERROR {
+    EXISTS = "tag already exists",
+    NOT_EXISTS = "tag does not exist",
+    MISSING_PARAMETERS = "missing parameters",
+    OPER_ERROR = "operation error"
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TAG_ERROR = void 0;
+var TAG_ERROR;
+(function (TAG_ERROR) {
+    TAG_ERROR["EXISTS"] = "tag already exists";
+    TAG_ERROR["NOT_EXISTS"] = "tag does not exist";
+    TAG_ERROR["MISSING_PARAMETERS"] = "missing parameters";
+    TAG_ERROR["OPER_ERROR"] = "operation error";
+})(TAG_ERROR = exports.TAG_ERROR || (exports.TAG_ERROR = {}));
+//# sourceMappingURL=error.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { TagsConfiguration as Configuration } from './configuration';
+export * from './manager';
+export * from './service';
+export * from './interface';
+export * from './error';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.TagsConfiguration; } });
+__exportStar(require("./manager"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./error"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,84 @@
+export interface ITagServiceInitOptions {
+    group: string;
+    dialect?: ITagDialect;
+}
+export type ITagDialectOption = {
+    dialectType: 'memory';
+} | ITagMysqlDialectOption | ITagUserDialect;
+export interface ITagUserDialect {
+    dialectType: string;
+    dialect: ITagDialect;
+}
+export type IMysqlQuery = (sql: string, placeholder?: any[]) => [any, any];
+export interface ITagMysqlDialectOption {
+    dialectType: 'mysql';
+    sync?: boolean;
+    tablePrefix?: string;
+    tableSeparator?: string;
+    instance: {
+        query: IMysqlQuery;
+    };
+}
+export interface ITagDefine {
+    name: string;
+    desc?: string;
+}
+export interface ITagItem extends ITagDefine {
+    id: number;
+    createAt: number;
+    updateAt: number;
+}
+export declare abstract class ITagDialect {
+    abstract ready(): Promise<void>;
+    abstract getInstance(instanceName: string): ITagDialectInstance;
+}
+export declare abstract class ITagDialectInstance {
+    abstract new(tagDefine: ITagDefine): Promise<ITagOperResult>;
+    abstract remove(tagIdOrName: number | string): Promise<ITagOperResult>;
+    abstract update(tagIdOrName: number | string, params: Partial<ITagDefine>): Promise<ITagOperResult>;
+    abstract list(listOptions?: ITagSearchOptions): Promise<ITagListResult<ITagItem>>;
+    abstract bind(bindOptions: ITagBindOptions): Promise<ITagOperResult>;
+    abstract unbind(unbindOptions: ITagUnBindOptions): Promise<ITagOperResult>;
+    abstract listObjects(listOptions?: ITagListInstanceOptions): Promise<ITagListResult<number>>;
+    abstract listObjectTags(listOptions?: ITagListInstanceTagsOptions): Promise<ITagListResult<ITagItem>>;
+}
+export interface ITagOperResult {
+    success: boolean;
+    message: string;
+    id?: number;
+}
+export interface ITagListResult<ListType> {
+    list: ListType[];
+    total?: number;
+}
+export interface ITagSearchOptions extends ITagPages {
+    tags?: Array<number | string>;
+    type?: MATCH_TYPE;
+}
+export interface ITagPages {
+    count?: boolean;
+    pageSize?: number;
+    page?: number;
+}
+export interface ITagBindOptions extends ITagInstance {
+    tags: Array<number | string>;
+    autoCreateTag?: boolean;
+}
+export interface ITagUnBindOptions extends ITagInstance {
+    tags: Array<number | string>;
+}
+export interface ITagListInstanceTagsOptions extends ITagInstance, ITagPages {
+}
+export interface ITagInstance {
+    objectId: number;
+}
+export declare enum MATCH_TYPE {
+    And = "and",
+    Or = "or"
+}
+export interface ITagListInstanceOptions extends ITagPages {
+    tags?: Array<string | number>;
+    count?: boolean;
+    type?: MATCH_TYPE;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATCH_TYPE = exports.ITagDialectInstance = exports.ITagDialect = void 0;
+class ITagDialect {
+}
+exports.ITagDialect = ITagDialect;
+class ITagDialectInstance {
+}
+exports.ITagDialectInstance = ITagDialectInstance;
+var MATCH_TYPE;
+(function (MATCH_TYPE) {
+    // 交集
+    MATCH_TYPE["And"] = "and";
+    // 并集
+    MATCH_TYPE["Or"] = "or";
+})(MATCH_TYPE = exports.MATCH_TYPE || (exports.MATCH_TYPE = {}));
+//# sourceMappingURL=interface.js.map

package/dist/manager.d.ts

@@ -0,0 +1,10 @@
+import { ServiceFactory, ServiceFactoryConfigOption } from '@midwayjs/core';
+import { ITagDialectOption } from './interface';
+import { TagClient } from './service';
+export declare class TagServiceFactory extends ServiceFactory<TagClient> {
+    tags: ServiceFactoryConfigOption<ITagDialectOption>;
+    init(): Promise<void>;
+    createClient(config: ITagDialectOption, name: string): Promise<TagClient>;
+    getName(): string;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/manager.js

@@ -0,0 +1,52 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagServiceFactory = void 0;
+const core_1 = require("@midwayjs/core");
+const dialect_1 = require("./dialect");
+const service_1 = require("./service");
+let TagServiceFactory = class TagServiceFactory extends core_1.ServiceFactory {
+    async init() {
+        await this.initClients(this.tags);
+    }
+    async createClient(config, name) {
+        let dialect;
+        if (config.dialect) {
+            dialect = config.dialect;
+        }
+        else if (config.dialectType === 'mysql') {
+            dialect = new dialect_1.MysqlDialect(config);
+        }
+        else {
+            dialect = new dialect_1.MemoryDialect();
+        }
+        await dialect.ready();
+        return new service_1.TagClient(dialect, name);
+    }
+    getName() {
+        return 'tags';
+    }
+};
+__decorate([
+    (0, core_1.Config)('tags'),
+    __metadata("design:type", Object)
+], TagServiceFactory.prototype, "tags", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TagServiceFactory.prototype, "init", null);
+TagServiceFactory = __decorate([
+    (0, core_1.Singleton)()
+], TagServiceFactory);
+exports.TagServiceFactory = TagServiceFactory;
+//# sourceMappingURL=manager.js.map

package/dist/service.d.ts

@@ -0,0 +1,16 @@
+import { ITagBindOptions, ITagDefine, ITagDialect, ITagItem, ITagListInstanceOptions, ITagListInstanceTagsOptions, ITagListResult, ITagOperResult, ITagSearchOptions, ITagUnBindOptions } from './interface';
+export * from './interface';
+export * from './error';
+export declare class TagClient {
+    private dialect;
+    constructor(dialect: ITagDialect, tagGroup: string);
+    new(tagDefine: ITagDefine): Promise<ITagOperResult>;
+    remove(tagIdOrName: number | string): Promise<ITagOperResult>;
+    update(tagIdOrName: number | string, params: Partial<ITagDefine>): Promise<ITagOperResult>;
+    list(listOptions?: ITagSearchOptions): Promise<ITagListResult<ITagItem>>;
+    bind(bindOptions: ITagBindOptions): Promise<ITagOperResult>;
+    unbind(unbindOptions: ITagUnBindOptions): Promise<ITagOperResult>;
+    listObjects(listOptions?: ITagListInstanceOptions): Promise<ITagListResult<number>>;
+    listObjectTags(listOptions?: ITagListInstanceTagsOptions): Promise<ITagListResult<ITagItem>>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagClient = void 0;
+const error_1 = require("./error");
+const utils_1 = require("./utils");
+__exportStar(require("./interface"), exports);
+__exportStar(require("./error"), exports);
+class TagClient {
+    constructor(dialect, tagGroup) {
+        this.dialect = dialect.getInstance(tagGroup);
+    }
+    async new(tagDefine) {
+        return this.dialect.new(tagDefine);
+    }
+    async remove(tagIdOrName) {
+        return this.dialect.remove(tagIdOrName);
+    }
+    async update(tagIdOrName, params) {
+        return this.dialect.update(tagIdOrName, params);
+    }
+    async list(listOptions) {
+        return this.dialect.list({
+            page: 1,
+            pageSize: 20,
+            ...listOptions,
+        });
+    }
+    async bind(bindOptions) {
+        var _a;
+        if (!((_a = bindOptions.tags) === null || _a === void 0 ? void 0 : _a.length)) {
+            return (0, utils_1.error)(error_1.TAG_ERROR.MISSING_PARAMETERS, { need: 'tags' });
+        }
+        return this.dialect.bind(bindOptions);
+    }
+    async unbind(unbindOptions) {
+        return this.dialect.unbind(unbindOptions);
+    }
+    async listObjects(listOptions) {
+        return this.dialect.listObjects({
+            page: 1,
+            pageSize: 20,
+            tags: [],
+            ...listOptions,
+        });
+    }
+    async listObjectTags(listOptions) {
+        return this.dialect.listObjectTags({
+            page: 1,
+            pageSize: 20,
+            ...listOptions,
+        });
+    }
+}
+exports.TagClient = TagClient;
+//# sourceMappingURL=service.js.map

package/dist/utils.d.ts

@@ -0,0 +1,14 @@
+export declare const success: (data?: any, message?: string) => any;
+export declare const error: (message: string, data?: any) => any;
+export declare const getPageOpions: (page?: number, pageSize?: number) => {
+    limit: number;
+    offset: number;
+    end: number;
+};
+export declare const formatMatchLike: (matchItem: string) => {
+    matchEnd: boolean;
+    matchStart: boolean;
+    text: string;
+    stashedText: string;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMatchLike = exports.getPageOpions = exports.error = exports.success = void 0;
+const success = (data = {}, message = 'success') => {
+    return {
+        success: true,
+        message,
+        ...data,
+    };
+};
+exports.success = success;
+const error = (message, data) => {
+    return {
+        success: false,
+        message,
+        ...data,
+    };
+};
+exports.error = error;
+const getPageOpions = (page = 1, pageSize = 20) => {
+    if (page === 1 && pageSize === Infinity) {
+        return {
+            limit: 0,
+            offset: Infinity,
+            end: Infinity,
+        };
+    }
+    const pageSizeNumber = +pageSize;
+    const start = (+page - 1) * pageSizeNumber;
+    const end = start + pageSizeNumber;
+    return {
+        limit: start,
+        offset: pageSizeNumber,
+        end,
+    };
+};
+exports.getPageOpions = getPageOpions;
+const formatMatchLike = (matchItem) => {
+    let matchItemText = matchItem;
+    let matchStart = true;
+    let matchEnd = true;
+    // xxx% macth start with xxx
+    if (matchItem.endsWith('%')) {
+        matchEnd = false;
+        matchItemText = matchItemText.slice(0, -1);
+    }
+    // %xxx macth end with xxx
+    if (matchItem.startsWith('%')) {
+        matchStart = false;
+        matchItemText = matchItemText.slice(1);
+    }
+    return {
+        matchEnd,
+        matchStart,
+        text: matchItemText,
+        stashedText: matchItem.replace(/'/g, ''),
+    };
+};
+exports.formatMatchLike = formatMatchLike;
+//# sourceMappingURL=utils.js.map

package/index.d.ts

@@ -0,0 +1,9 @@
+import { ITagDialectOption } from './dist';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    tags?: ServiceFactoryConfigOption<ITagDialectOption>;
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@midwayjs/tags",
+  "version": "3.0.0",
+  "description": "Midway Tag System",
+  "main": "dist/index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
+    "ci": "npm run test"
+  },
+  "keywords": [],
+  "author": "",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@midwayjs/core": "^3.11.0",
+    "@midwayjs/express": "^3.11.0",
+    "@midwayjs/faas": "^3.11.0",
+    "@midwayjs/koa": "^3.11.0",
+    "@midwayjs/mock": "^3.11.0",
+    "@midwayjs/serverless-app": "^3.11.0",
+    "@midwayjs/web": "^3.11.0",
+    "mysql2": "^2.3.3"
+  }
+}