@domain.js/main 0.1.3 → 0.1.8

package/.husky/pre-commit

@@ -4,4 +4,4 @@ if [ ! -f "$(dirname "$0")/_/husky.sh" ]; then
 fi
 . "$(dirname "$0")/_/husky.sh"
 
-ts-node src/cli/index.ts loadDeps ./ ts && npm run lint-staged && npm run build 
+ts-node src/cli/index.ts loadDeps ./src/deps ts && npm run lint-staged && npm run build 

package/dist/cli/index.js

@@ -31,10 +31,11 @@ const codeStyleFormat = (targetFile) => new Promise((resolve, reject) => {
     });
 });
 const makeDefineFile = async (modules, targetFile, isTS) => {
+    const dirname = path.dirname(targetFile);
     const content = ["// domain-cli 自动生成"];
     const _exports = [];
     for (let i = 0; i < modules.length; i += 1) {
-        const name = modules[i];
+        const name = path.relative(dirname, modules[i]);
         const variable = filePath2Var(name);
         if (isTS) {
             content.push(`import * as ${variable} from "./${name}"`);
@@ -76,10 +77,10 @@ const checkHookExport = (_dir) => {
         }
     }
 };
-const loadDeps = async (rootDir = process.cwd(), ext = "js") => {
+const loadDeps = async (rootDir, ext = "js") => {
     const isTS = ext === "ts";
     const modules = [];
-    const dir = path.resolve(rootDir, "src/deps/");
+    const dir = path.resolve(rootDir, "./");
     for (const x of fs.readdirSync(dir)) {
         // 忽略隐藏目录
         if (x[0] === ".")
@@ -90,10 +91,10 @@ const loadDeps = async (rootDir = process.cwd(), ext = "js") => {
         if (!stat.isDirectory())
             continue;
         checkHookExport(_dir);
-        modules.push(x);
+        modules.push(path.join(dir, x));
     }
     // 按字典排序，后续有变动的时候不容易冲突
-    const targetFile = path.resolve(rootDir, `src/deps/defines.${ext}`);
+    const targetFile = path.resolve(rootDir, `./defines.${ext}`);
     await makeDefineFile(modules.sort(), targetFile, isTS);
 };
 const checkService = (_dir) => {
@@ -106,7 +107,7 @@ const checkService = (_dir) => {
 const loadServices = async (rootDir = process.cwd(), ext = "js") => {
     const isTS = ext === "ts";
     const modules = [];
-    const dir = path.resolve(rootDir, "src/services/");
+    const dir = path.resolve(rootDir, "src/domain/services/");
     for (const x of fs.readdirSync(dir)) {
         // 忽略隐藏目录, 忽略私有目录
         if (x[0] === "." || x[0] === "_")
@@ -117,81 +118,55 @@ const loadServices = async (rootDir = process.cwd(), ext = "js") => {
         if (!stat.isDirectory())
             continue;
         checkService(_dir);
-        modules.push(x);
+        modules.push(path.join(dir, x));
     }
     // 按字典排序，后续有变动的时候不容易冲突
-    const targetFile = path.resolve(rootDir, `src/services/defines.${ext}`);
+    const targetFile = path.resolve(rootDir, `src/domain/services/defines.${ext}`);
     await makeDefineFile(modules.sort(), targetFile, isTS);
 };
-const deepLoadDir = (root, parent, files = []) => {
-    const paths = {};
-    const dir = path.resolve(root, parent);
+/**
+ * 尝试读取目录下的文件
+ * @param dir 目录路径
+ * @param list 读取到schema后压入改列表
+ */
+const tryReadSchemas = (dir, list, isTS = false) => {
+    if (!fs.existsSync(dir))
+        return;
+    const stat = fs.statSync(dir);
+    if (stat.isFile())
+        return;
     for (const x of fs.readdirSync(dir)) {
-        // 忽略隐藏目录
-        if (x[0] === ".")
+        if (x.startsWith("."))
             continue;
-        const file = path.resolve(dir, x);
-        const stat = fs.statSync(file);
-        const { name, ext } = path.parse(x);
-        const relativeFilePath = `./${path.join(parent, name)}`;
-        const moduleName = file2Module(name);
-        // 如果是文件则记录
-        if (stat.isFile()) {
-            if (ext === ".ts") {
-                const JSFile = path.resolve(dir, `${name}.js`);
-                // 对应的js文件存在，则ts文件忽略
-                if (fs.existsSync(JSFile))
-                    continue;
-                // 对应的js文件不存在，抛出异常提示用户要先编译
-                throw Error(`请先编译ts文件: ${file}`);
-            }
-            files.push(relativeFilePath);
-            paths[moduleName] = relativeFilePath;
+        const ext = path.extname(x);
+        if (isTS && ext !== ".ts")
             continue;
-        }
-        if (stat.isDirectory()) {
-            paths[moduleName] = deepLoadDir(root, relativeFilePath, files);
-        }
+        if (!isTS && ext !== ".js")
+            continue;
+        list.push(path.join(dir, path.basename(x, isTS ? ".ts" : ".js")));
     }
-    return paths;
 };
-const deepLoadModule = async (rootDir, targetFile) => {
-    const files = [];
-    const paths = deepLoadDir(rootDir, "./", files);
-    const { ext } = path.parse(targetFile);
-    // 按字典排序，后续有变动的时候不容易冲突
-    files.sort();
-    const relative = path.relative(path.dirname(targetFile), rootDir);
-    const isTS = ext === ".ts";
-    const content = ["// domain-cli 自动生成"];
-    for (let i = 0; i < files.length; i += 1) {
-        const name = files[i];
-        const _path = `./${path.join(relative, name)}`;
-        const variable = filePath2Var(name);
-        if (isTS) {
-            content.push(`import * as ${variable} from "${_path}"`);
-        }
-        else {
-            content.push(`const ${variable} = require("${_path}")`);
-        }
-    }
-    // 处理导出
-    content.push("\n");
-    let _exports = JSON.stringify(paths, null, 2);
-    for (let i = 0; i < files.length; i += 1) {
-        _exports = _exports.replace(`"${files[i]}"`, filePath2Var(files[i]));
-    }
-    if (isTS) {
-        content.push(`export = ${_exports}`);
-    }
-    else {
-        content.push(`module.exports = ${_exports}`);
+const loadSchemas = async (rootDir = process.cwd(), ext = "js") => {
+    const isTS = ext === "ts";
+    const modules = [];
+    const dir = path.resolve(rootDir, "src/domain/services/");
+    for (const x of fs.readdirSync(dir)) {
+        // 忽略隐藏目录, 忽略私有目录
+        if (x[0] === "." || x[0] === "_")
+            continue;
+        const _dir = path.resolve(dir, x);
+        const stat = fs.statSync(_dir);
+        // 非目录忽略，模块必须是目录
+        if (!stat.isDirectory())
+            continue;
+        // 尝试读取子目录里的 schemas 目录
+        tryReadSchemas(path.join(_dir, "schemas"), modules, isTS);
     }
-    fs.writeFileSync(targetFile, content.join("\n"));
-    await codeStyleFormat(targetFile);
-    console.log(`Completed: ${targetFile}`);
+    // 按字典排序，后续有变动的时候不容易冲突
+    const targetFile = path.resolve(rootDir, `src/domain/services/schemas.${ext}`);
+    await makeDefineFile(modules.sort(), targetFile, isTS);
 };
-const actions = { loadDeps, loadServices, deepLoadModule };
+const actions = { loadDeps, loadServices, loadSchemas };
 const main = async (command) => {
     const action = actions[command];
     if (!action) {

package/dist/cli/schema2ts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/schema2ts.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const json_schema_to_typescript_1 = require("json-schema-to-typescript");
+const _require = require;
+async function main(file, single = false, name = "Params") {
+    const stats = fs.statSync(file);
+    if (stats.isFile()) {
+        const arr = file.split(".");
+        if (arr.pop() !== "js")
+            return;
+        const obj = _require(file);
+        if (!single) {
+            if (!Array.isArray(obj))
+                return;
+            if (typeof obj[1] !== "object")
+                return;
+        }
+        try {
+            const ts = await (0, json_schema_to_typescript_1.compile)(single ? obj : obj[1], name);
+            arr.push("d.ts");
+            fs.writeFileSync(arr.join("."), ts);
+        }
+        catch (e) {
+            console.error(file, e);
+        }
+        return;
+    }
+    const files = fs.readdirSync(file);
+    for await (const x of files) {
+        if (x === "." || x === "..")
+            continue;
+        await main(path.resolve(file, x), single, name);
+    }
+}
+main(process.argv[2], process.argv[3] === "single", process.argv[4]);

package/dist/deps/cia/index.d.ts

@@ -56,6 +56,8 @@ export declare function Main(cnf: Cnf, deps: Deps): {
     link: (name: string, type: string, waiter: Function) => void;
     submit: (name: string, data: any, callback?: Function | undefined) => void;
     setFn: (type: "error" | "timeout", fn: (...args: any[]) => any) => void;
+    domainPaths: Set<string>;
+    modelHooks: Set<string>;
 };
 export declare const Deps: string[];
 export {};

package/dist/deps/cia/index.js

@@ -282,7 +282,27 @@ function Main(cnf, deps) {
     const isExiting = () => Boolean(exiting);
     // 进程是否已经退出
     const isExited = () => Boolean(exited);
-    return { isExiting, isExited, checkReady, getStats, getUnlinks, regist, link, submit, setFn };
+    /**
+     * 领域方法注册到 cia 上的路径集合
+     */
+    const domainPaths = new Set();
+    /**
+     * Model hook 注册到 cia 上的路径集合
+     */
+    const modelHooks = new Set();
+    return {
+        isExiting,
+        isExited,
+        checkReady,
+        getStats,
+        getUnlinks,
+        regist,
+        link,
+        submit,
+        setFn,
+        domainPaths,
+        modelHooks,
+    };
 }
 exports.Main = Main;
 exports.Deps = ["_", "async", "logger", "utils", "redis", "graceful", "uuid"];

package/dist/deps/cron/index.js

@@ -93,4 +93,4 @@ function Main(cnf, deps) {
     return { regist, start, getStats };
 }
 exports.Main = Main;
-exports.Deps = ["cia", "humanInterval", "cronParser"];
+exports.Deps = ["myCia", "humanInterval", "cronParser"];

package/dist/deps/defines.d.ts

@@ -1,12 +1,12 @@
 import * as aes from "./aes";
 import * as cache from "./cache";
 import * as checker from "./checker";
-import * as cia from "./cia";
 import * as counter from "./counter";
 import * as cron from "./cron";
 import * as graceful from "./graceful";
 import * as hash from "./hash";
 import * as logger from "./logger";
+import * as myCia from "./myCia";
 import * as parallel from "./parallel";
 import * as redis from "./redis";
 import * as request from "./request";
@@ -18,12 +18,12 @@ declare const _default: {
     aes: typeof aes;
     cache: typeof cache;
     checker: typeof checker;
-    cia: typeof cia;
     counter: typeof counter;
     cron: typeof cron;
     graceful: typeof graceful;
     hash: typeof hash;
     logger: typeof logger;
+    myCia: typeof myCia;
     parallel: typeof parallel;
     redis: typeof redis;
     request: typeof request;

package/dist/deps/defines.js

@@ -3,12 +3,12 @@
 const aes = require("./aes");
 const cache = require("./cache");
 const checker = require("./checker");
-const cia = require("./cia");
 const counter = require("./counter");
 const cron = require("./cron");
 const graceful = require("./graceful");
 const hash = require("./hash");
 const logger = require("./logger");
+const myCia = require("./myCia");
 const parallel = require("./parallel");
 const redis = require("./redis");
 const request = require("./request");
@@ -20,12 +20,12 @@ module.exports = {
     aes,
     cache,
     checker,
-    cia,
     counter,
     cron,
     graceful,
     hash,
     logger,
+    myCia,
     parallel,
     redis,
     request,

package/dist/deps/myCia/errors.d.ts

@@ -0,0 +1,6 @@
+declare const _default: () => {
+    [key: string]: (...args: any[]) => Error & {
+        code?: string | undefined;
+    };
+};
+export default _default;

package/dist/deps/myCia/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = require("util");
+exports.default = () => {
+    const defines = [
+        ["duplicatRegistMessage", "The message has been registed: %s"],
+        ["registWhenReadyAfter", "The message dont registed when mcenter be ready after: %s"],
+        [
+            "submitUnregistedMessage",
+            "The message has not been registed: %s, data: %o, when will submit",
+        ],
+        ["linkUnregistedMessage", "The message has not been registed: %s, when will link"],
+        [
+            "linkUnknowTypes",
+            "The message link type unknown, message name is: %s, type is: %s, when will link",
+        ],
+        [
+            "linkDuplicateType",
+            "The message link type duplicate, message name is: %s, type is: %s, when will link",
+        ],
+        [
+            "linkListernerMustBeFunctionType",
+            "The message link waiter must be a function, message name is: %s, type is: %s, when will link",
+        ],
+        ["setFnNotAllowed", "Set function but unknown type: %s"],
+    ];
+    const fns = {};
+    for (const [code, message] of defines) {
+        fns[code] = (...args) => {
+            const error = Error(util.format(message, ...args));
+            error.code = code;
+            return error;
+        };
+    }
+    return fns;
+};

package/dist/deps/myCia/index.d.ts

@@ -0,0 +1,63 @@
+import * as _ from "lodash";
+import * as async from "async";
+import { v4 } from "uuid";
+interface Cnf {
+    cia?: {
+        concurrency?: number;
+        storeKey?: string;
+    };
+}
+interface Deps {
+    _: Pick<typeof _, "pick" | "map" | "isFunction">;
+    async: Pick<typeof async, "eachSeries" | "queue">;
+    uuid: {
+        v4: typeof v4;
+    };
+    logger: {
+        info: (...args: any[]) => void;
+        error: (...args: any[]) => void;
+    };
+    redis: {
+        hset: Function;
+        hdel: Function;
+        hgetall: Function;
+    };
+    graceful: {
+        exit: (fn: () => Promise<void>) => void;
+    };
+    U: {
+        tryCatchLog<Fn extends (...args: any[]) => any>(fn: Fn, errorFn: (...args: any[]) => any): Fn;
+    };
+}
+export interface Stats {
+    pendings: number;
+    doings: number;
+    errors: number;
+    dones: number;
+}
+declare type Type = {
+    type: string;
+    timeout?: number;
+    validator?: Function;
+};
+export declare function Main(cnf: Cnf, deps: Deps): {
+    isExiting: () => boolean;
+    isExited: () => boolean;
+    checkReady: () => boolean;
+    getStats: () => {
+        [name: string]: Stats & {
+            _types: ({
+                type: string;
+            } & Stats)[];
+        };
+    };
+    getUnlinks: () => string[];
+    regist: (name: string, validator: Function | undefined, types: Type[]) => number;
+    link: (name: string, type: string, waiter: Function) => void;
+    submit: (name: string, data: any, callback?: Function | undefined) => void;
+    setFn: (type: "error" | "timeout", fn: (...args: any[]) => any) => void;
+    domainPaths: Set<string>;
+    modelHooks: Set<string>;
+};
+export declare const Deps: string[];
+export {};

package/dist/deps/myCia/index.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deps = exports.Main = void 0;
+const errors_1 = require("./errors");
+function Main(cnf, deps) {
+    const { _, async, uuid: { v4: uuid }, logger, redis, graceful, U: { tryCatchLog }, } = deps;
+    const { cia } = cnf;
+    const concurrency = Math.max(1, ((cia && cia.concurrency) || 10) | 0);
+    const storeKey = (cia && cia.storeKey) || "cia-store";
+    const errors = (0, errors_1.default)();
+    let doingCount = 0; // 正在执行的消息数量
+    let exited = false; // 是否已经完成退出
+    let exiting = false; // 是否正在退出
+    let readyToExitFn; // 完成退出前准备后执行函数
+    let unlinkdCount = 0; // 未被订阅的数量, 基于 {name}::{type} 判断
+    let isReady = false; // 系统是否已准备妥当
+    const registeds = {};
+    // 默认通知函数
+    const fns = {
+        error: logger.error,
+        timeout: logger.info,
+    };
+    // 记录监听回调函数
+    // { [${name}::${type}]: { [type]: fn } }
+    const waiters = new Map();
+    // 更新等待数量
+    const updatePendings = (registed) => {
+        const { result = {}, types } = registed;
+        const withouts = new Set(Object.keys(result));
+        registed.pendings += 1;
+        types.forEach((x) => {
+            if (!withouts.has(x.type))
+                x.pendings += 1;
+        });
+    };
+    // 更新 doings 统计信息
+    const updateDoings = (item) => {
+        item.pendings -= 1;
+        item.doings += 1;
+    };
+    // 更新 errors 统计信息
+    const updateErrors = (item) => {
+        item.doings -= 1;
+        item.errors += 1;
+    };
+    // 更新 dones 统计信息
+    const updateDones = (item) => {
+        item.doings -= 1;
+        item.dones += 1;
+    };
+    // 消息分发函数，分发到对应的订阅函数上
+    const dispatch = async (item) => {
+        const { id, name, data, result = {}, callback } = item;
+        const registed = registeds[name];
+        const { types } = registed;
+        const withouts = new Set(Object.keys(result));
+        updateDoings(registed);
+        doingCount += 1;
+        let errorCount = 0;
+        await async.eachSeries(types, async (_type) => {
+            const { type, timeout, validator } = _type;
+            // 看看是否有设置要忽略掉某些订阅者
+            // 这个功能主要是留给应用无故中断后系统自动恢复的任务执行
+            if (withouts && withouts.has(type))
+                return;
+            if (exiting)
+                return;
+            const fn = waiters.get(`${name}::${type}`);
+            const startAt = Date.now();
+            let err = null;
+            let ret = null;
+            try {
+                updateDoings(_type);
+                ret = await fn(data);
+                if (validator)
+                    validator(ret);
+                updateDones(_type);
+            }
+            catch (e) {
+                updateErrors(_type);
+                fns.error(e, id, name, type, data);
+                errorCount += 1;
+                err = e;
+            }
+            const consumedMS = Date.now() - startAt;
+            if (timeout && timeout < consumedMS)
+                fns.timeout(consumedMS, id, name, type);
+            result[type] = [err, ret, consumedMS];
+            // 记录执行结果
+            logger.info(`cia.dispatch\t${id}\t${type}`, result[type]);
+        });
+        doingCount -= 1;
+        if (errorCount) {
+            updateErrors(registed);
+        }
+        else {
+            updateDones(registed);
+        }
+        // submit 设置了callback 要记得执行回调函数
+        if (callback)
+            callback(result);
+        // 正在退出，且完成的不等于总共的，则需要储存, 以备下次启动后执行
+        if (exiting) {
+            if (Object.keys(result).length !== types.length) {
+                item.result = result;
+                // 存储以备下次启动恢复执行
+                await redis.hset(storeKey, item.id, JSON.stringify(item));
+            }
+            // 全部处理完毕后，执行退出
+            if (!doingCount) {
+                exited = true;
+                exiting = false;
+                readyToExitFn();
+            }
+        }
+    };
+    const statsFields = Object.freeze(["pendings", "doings", "dones", "errors"]);
+    // 获取统计信息
+    const getStats = () => {
+        const stats = {};
+        for (const name of Object.keys(registeds)) {
+            const { types } = registeds[name];
+            stats[name] = {
+                ..._.pick(registeds[name], statsFields),
+                _types: types.map((x) => _.pick(x, "type", ...statsFields)),
+            };
+        }
+        return stats;
+    };
+    // 内部消息队列, 初始化后立即暂定，等待 regist, link 都准备好了在开始执行
+    // 这样就不会有未成功订阅函数执行遗漏的问题了
+    // 例如: A 函数要监听 1 好消息的 save 类型，结果在完成订阅前，已经有某个区域 submit 了 1 号事件
+    //       如果队列一开始不暂停就会出现A函数遗漏执行
+    const queue = async.queue(dispatch, concurrency);
+    queue.pause();
+    graceful.exit(async () => {
+        exiting = true;
+        await new Promise((resolve) => {
+            // 如果队列已经清空，且没有正在执行的消息，则直接退出
+            if (!queue.length() && !doingCount) {
+                exited = true;
+                exiting = false;
+                resolve();
+            }
+            else {
+                readyToExitFn = resolve;
+            }
+        });
+    });
+    // 恢复上次残留的消息订阅执行
+    const recover = async () => {
+        const items = await redis.hgetall(storeKey);
+        if (!items)
+            return;
+        for await (const id of Object.keys(items)) {
+            const item = items[id];
+            const ok = await redis.hdel(storeKey, id);
+            if (ok !== 1)
+                continue;
+            try {
+                const data = JSON.parse(item);
+                const { name } = data;
+                queue.push(data);
+                updatePendings(registeds[name]);
+                logger.info("cia-recover: %s", item);
+            }
+            catch (e) {
+                logger.error(e);
+            }
+        }
+    };
+    // regist 消息注册，提前注册好需要submit和link的消息
+    // 这么做的目的是可以随时检测是否所有的消息都消费者，消费者类型是否正确
+    // 同时在submit的时候也可以检测发送的数据是否符合规定的格式
+    // name: String 消息名称
+    // validator?: Function 消息体数据格式验证函数
+    // types: [{
+    //    type: 'updateUser', // 类型名称
+    //    timeout?: 100, // 执行超时限定, 单位毫秒，可选 默认为 0, 不限制
+    //    validator?: fn, // 返回值格式验证函数, 可选
+    // }]
+    const regist = (name, validator, types) => {
+        if (isReady)
+            throw errors.registWhenReadyAfter(name);
+        if (registeds[name])
+            throw errors.duplicatRegistMessage(name);
+        const typeNames = new Set(_.map(types, "type"));
+        types.forEach((x) => {
+            Object.assign(x, { pendings: 0, dones: 0, doings: 0, errors: 0 });
+        });
+        const item = {
+            validator,
+            types: types,
+            typeNames,
+            pendings: 0,
+            dones: 0,
+            doings: 0,
+            errors: 0,
+        };
+        unlinkdCount += typeNames.size;
+        registeds[name] = item;
+        return Object.keys(registeds).length;
+    };
+    // start 启动系统执行, 这之前一定要regist 和 link 都准备好
+    const start = async () => {
+        queue.resume();
+        await recover();
+    };
+    // check 消息注册、监听检测
+    // 检查是否存在注册了的消息，但没有人监听消费
+    const checkReady = () => {
+        if (unlinkdCount !== 0)
+            return false;
+        if (!isReady) {
+            isReady = true;
+            start();
+        }
+        return true;
+    };
+    // link 消息订阅
+    const link = (name, type, waiter) => {
+        if (!registeds[name])
+            throw errors.linkUnregistedMessage(name);
+        const { typeNames } = registeds[name];
+        if (!typeNames.has(type))
+            throw errors.linkUnknowTypes(name, type);
+        if (!_.isFunction(waiter))
+            throw errors.linkListernerMustBeFunctionType(name, type);
+        const key = `${name}::${type}`;
+        if (waiters.get(key))
+            throw errors.linkDuplicateType(name, type);
+        waiters.set(key, waiter);
+        unlinkdCount -= 1;
+        checkReady();
+    };
+    // submit 消息发布
+    // name string 消息名称
+    // data any 消息数据
+    // callback function 消息执行完毕回调
+    const submit = (name, data, callback) => {
+        if (!registeds[name]) {
+            // 这里记录error就可以了。throw没有意义，因为submit是异步的
+            // throw error并没有被捕获，还会导致调用方的后续代码不执行
+            logger.error(errors.submitUnregistedMessage(name, data));
+            return;
+        }
+        if (callback && !_.isFunction(callback))
+            callback = undefined;
+        const { validator } = registeds[name];
+        if (validator)
+            validator(data);
+        const id = uuid();
+        queue.push({ id, name, data, callback });
+        updatePendings(registeds[name]);
+        logger.info(`cia.submit\t${id}`, { name, data });
+    };
+    // 设置通知函数，错误通知，超时通知
+    // 在消息分发执行的时候遇到错误会调用错误通知函数
+    // 在消息分发执行的时候遇到超时会调用超时通知函数
+    // type string 类型，error or timeout
+    // fn function 通知函数
+    const setFn = (type, fn) => {
+        if (!fns[type])
+            throw errors.setFnNotAllowed(type);
+        // 这里之所以会用 tryCatchLog 封装函数，是不想让这些函数的执行影响主流程
+        // 这些函数内部抛出的异常不会导致主流程执行中断
+        fns[type] = tryCatchLog(fn, logger.error);
+    };
+    // 获取未被连接的任务消息
+    const getUnlinks = () => {
+        const losts = [];
+        for (const name of Object.keys(registeds)) {
+            for (const { type } of registeds[name].types) {
+                const key = `${name}::${type}`;
+                if (!waiters.has(key))
+                    losts.push(key);
+            }
+        }
+        return losts;
+    };
+    // 进程是否正在退出
+    const isExiting = () => Boolean(exiting);
+    // 进程是否已经退出
+    const isExited = () => Boolean(exited);
+    /**
+     * 领域方法注册到 cia 上的路径集合
+     */
+    const domainPaths = new Set();
+    /**
+     * Model hook 注册到 cia 上的路径集合
+     */
+    const modelHooks = new Set();
+    return {
+        isExiting,
+        isExited,
+        checkReady,
+        getStats,
+        getUnlinks,
+        regist,
+        link,
+        submit,
+        setFn,
+        domainPaths,
+        modelHooks,
+    };
+}
+exports.Main = Main;
+exports.Deps = ["_", "async", "logger", "utils", "redis", "graceful", "uuid"];

package/dist/deps/request/index.js

@@ -19,7 +19,7 @@ function Main(cnf, deps) {
         const d = r.data;
         if (typeof d === "string")
             return [r.status, d];
-        return [d.code || r.status, d.message || r.statusText];
+        return [d.code || r.status, d.message || JSON.stringify(d)];
     })().join("\t");
     if (!cnf.axios)
         cnf.axios = {};

package/dist/deps/signer/index.d.ts

@@ -5,7 +5,7 @@ export interface Opt {
     /** Key for signature calculation */
     key: string;
     /** Second timestamp */
-    timestamp: number;
+    timestamp: number | string;
     /** Signature algorithm, fixed as hmacsha256 */
     signMethod: "HmacSHA256";
     /** Signature version, fixed as 1 */
@@ -37,7 +37,7 @@ export declare function Main(): {
         readonly "x-auth-signature": string;
         readonly "x-auth-key": string;
         readonly "x-auth-method": string;
-        readonly "x-auth-timestamp": number;
+        readonly "x-auth-timestamp": string;
         readonly "x-auth-sign-method": "HmacSHA256";
         readonly "x-auth-sign-version": "1";
     };

package/dist/deps/signer/index.js

@@ -37,7 +37,7 @@ function Main() {
             const opt = {
                 uri,
                 key,
-                timestamp: (Date.now() / 1000) | 0,
+                timestamp: `${(Date.now() / 1000) | 0}`,
                 signMethod: "HmacSHA256",
                 signVersion: "1",
                 method,

package/dist/dm/index.d.ts

@@ -1,6 +1,6 @@
 interface ModuleInterface {
     Main: (...args: any[]) => any;
-    Deps?: string[];
+    Deps?: string[] | ReadonlyArray<string>;
     Before?: (...args: any[]) => any;
     After?: (...args: any[]) => void;
 }

package/dist/http/defines.d.ts

@@ -4,7 +4,6 @@ export interface Cnf {
     host?: string;
     bodyMaxBytes?: number;
     apisRoute?: string;
-    swaggerApiPath?: string;
     [propName: string]: any;
 }
 interface Sign {

package/dist/http/index.d.ts

@@ -6,7 +6,6 @@ interface Deps {
     domain: Domain;
     httpCodes: HttpCodes;
     getSchemaByPath: GetSchemaByPath;
-    swaggerDocJson?: any;
     makeProfileHook?: (obj: Profile, req: restify.Request) => any;
 }
 export declare function Main(cnf: Cnf, deps: Deps): () => restify.Server;

package/dist/http/index.js

@@ -6,7 +6,7 @@ const router_1 = require("./router");
 const utils_1 = require("./utils");
 function Main(cnf, deps) {
     const utils = (0, utils_1.Utils)(cnf);
-    const { routers, getSchemaByPath, domain, httpCodes, swaggerDocJson, makeProfileHook } = deps;
+    const { routers, getSchemaByPath, domain, httpCodes, makeProfileHook } = deps;
     const server = restify.createServer();
     server.use(restify.plugins.queryParser());
     server.use(restify.plugins.bodyParser({
@@ -21,7 +21,6 @@ function Main(cnf, deps) {
         getSchemaByPath,
         domain,
         apisRoute: cnf.apisRoute,
-        swagger: [cnf.swaggerApiPath, swaggerDocJson],
     });
     routers(router);
     // Http server start

package/dist/http/router.d.ts

@@ -11,11 +11,15 @@ interface Deps {
     apisRoute?: string;
     swagger?: [any, any];
 }
+/** 对 params 的处理函数 */
+declare type Handler = (params: any) => void;
+/** 对执行结构的处理 */
+declare type ResHandler = (results: any, res: restify.Response) => void;
 export declare function Router(deps: Deps): {
-    get: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
-    post: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
-    put: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
-    del: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Function | undefined, resHandler?: Function | undefined) => void;
+    get: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Handler | undefined, resHandler?: ResHandler | undefined) => void;
+    post: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Handler | undefined, resHandler?: ResHandler | undefined) => void;
+    put: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Handler | undefined, resHandler?: ResHandler | undefined) => void;
+    del: (routePath: string, ctlAct: string, code?: number, isList?: boolean, handler?: Handler | undefined, resHandler?: ResHandler | undefined) => void;
 } & {
     collection: (res: string, _routePath?: string | undefined, controller?: string | undefined) => void;
     model: (res: string, routePath?: string) => void;

package/dist/http/router.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Router = void 0;
 const _ = require("lodash");
 const errors = require("restify-errors");
-const swaggerUi = require("swagger-ui-restify");
 function Router(deps) {
-    const { domain, apisRoute, getSchemaByPath, utils, server, httpCodes = {}, makeProfileHook, swagger = ["", {}], } = deps;
-    const { ucwords, makeParams, makeProfile, outputCSV, jsonSchema2Swagger } = utils;
+    const { domain, apisRoute, getSchemaByPath, utils, server, httpCodes = {}, makeProfileHook, } = deps;
+    const { ucwords, makeParams, makeProfile, outputCSV } = utils;
     // 改写 HttpErrorToJSON 处理 data
     const HttpErrorToJSON = errors.HttpError.prototype.toJSON;
     errors.HttpError.prototype.toJSON = function toJSON() {
@@ -24,21 +23,8 @@ function Router(deps) {
             e.body.data = data;
         return e;
     };
-    const [apiSwagger, swaggerDocJson] = swagger;
     const apis = [];
     let apisHTML = "<h3>API 目录，点击可以查看参数格式定义</h3>";
-    let swaggerHtml = "";
-    if (apiSwagger) {
-        server.get(`/${apiSwagger}/*.*`, ...swaggerUi.serve);
-        server.get(`/${apiSwagger}`, (req, res) => {
-            res.writeHead(200, {
-                "Content-Length": Buffer.byteLength(swaggerHtml),
-                "Content-Type": "text/html",
-            });
-            res.write(swaggerHtml);
-            res.end();
-        });
-    }
     /** 判断是否需要提供apis的查询接口 */
     if (apisRoute) {
         server.get(`/${apisRoute}`, (req, res, next) => {
@@ -66,39 +52,6 @@ function Router(deps) {
             next();
         });
     }
-    const getAPISchemaDoc = (verb, route, methodPath) => {
-        if (!apiSwagger)
-            return;
-        let apiSchema = [];
-        let desc = "";
-        try {
-            apiSchema = getSchemaByPath(methodPath);
-            desc = apiSchema[1] ? apiSchema[1].description : "unknow";
-            apiSchema = jsonSchema2Swagger(apiSchema[1] ? apiSchema[1] : {}, verb, methodPath, swaggerDocJson);
-        }
-        catch (e) {
-            console.log(methodPath, "schema to swagger error.");
-        }
-        swaggerHtml = swaggerUi.generateHTML(swaggerDocJson, {
-            baseURL: `${swaggerDocJson.basePath}${apiSwagger}`,
-            explorer: true,
-        });
-        const apiTag = methodPath.split(".")[0];
-        swaggerDocJson.paths[route] = {
-            [verb]: {
-                "x-swagger-router-controller": methodPath,
-                operationId: methodPath,
-                tags: [apiTag],
-                externalDocs: {
-                    description: "查看接口参数 json schema 定义",
-                    url: `./${apisRoute}/_schema?path=${methodPath}`,
-                },
-                description: desc,
-                parameters: apiSchema || [],
-                responses: {},
-            },
-        };
-    };
     function register(verb, route, methodPath, code = 200, isList = false, handler, resHandler) {
         /**
          * 暂存起来，提供给apis接口来用
@@ -111,7 +64,6 @@ function Router(deps) {
         if (!method || !_.isFunction(method)) {
             throw Error(`Missing domain method: ${methodPath}`);
         }
-        getAPISchemaDoc(verb, route, methodPath);
         server[verb](route, async (req, res, next) => {
             const profile = makeProfile(req, methodPath, makeProfileHook);
             const params = makeParams(req);

package/dist/http/utils.d.ts

@@ -25,5 +25,4 @@ export declare function Utils(cnf: Cnf): {
      * 输出csv相关
      */
     outputCSV(rows: any[], params: any, res: restify.Response, isXLSX?: boolean): Promise<boolean>;
-    jsonSchema2Swagger(schema: any, verb: string, methodPath: string, swaggerDocJson: any): any[];
 };

package/dist/http/utils.js

@@ -144,41 +144,6 @@ function Utils(cnf) {
             }
             return true;
         },
-        jsonSchema2Swagger(schema, verb, methodPath, swaggerDocJson) {
-            if (verb === "post" || verb === "put" || verb === "patch") {
-                swaggerDocJson.definitions[methodPath] = schema;
-                return [
-                    {
-                        name: "body",
-                        in: "body",
-                        require: true,
-                        description: schema.description,
-                        operationId: methodPath,
-                        schema: {
-                            $ref: `#/definitions/${methodPath}`,
-                        },
-                    },
-                ];
-            }
-            const parameters = [];
-            if (!_.has(schema, "properties")) {
-                return parameters;
-            }
-            const requireds = schema.required ? schema.required : [];
-            for (const prop of Object.keys(schema.properties)) {
-                const val = schema.properties[prop];
-                const param = {
-                    name: prop,
-                    in: "query",
-                    ...val,
-                };
-                if (requireds.includes("prop")) {
-                    param.required = true;
-                }
-                parameters.push(param);
-            }
-            return parameters;
-        },
     };
     return utils;
 }

package/dist/index.d.ts

@@ -19,31 +19,31 @@ export declare function Main<T extends Readonly<Array<keyof TDeps>>>(features: T
     aes: typeof import("./deps/aes");
     cache: typeof import("./deps/cache");
     checker: typeof import("./deps/checker");
-    cia: typeof import("./deps/cia");
     counter: typeof import("./deps/counter");
     cron: typeof import("./deps/cron");
     graceful: typeof import("./deps/graceful");
     hash: typeof import("./deps/hash");
     logger: typeof import("./deps/logger");
+    myCia: typeof import("./deps/myCia");
     parallel: typeof import("./deps/parallel");
-    redis: typeof import("./deps/redis"); /** 模块名称联合类型 */
+    redis: typeof import("./deps/redis");
     request: typeof import("./deps/request");
     rest: typeof import("./deps/rest");
     schema: typeof import("./deps/schema");
     sequelize: typeof import("./deps/sequelize");
     signer: typeof import("./deps/signer");
-}[Include<"schema", RemoveReadonlyArray<T>> | Include<"logger", RemoveReadonlyArray<T>> | Include<"aes", RemoveReadonlyArray<T>> | Include<"request", RemoveReadonlyArray<T>> | Include<"sequelize", RemoveReadonlyArray<T>> | Include<"cache", RemoveReadonlyArray<T>> | Include<"redis", RemoveReadonlyArray<T>> | Include<"rest", RemoveReadonlyArray<T>> | Include<"parallel", RemoveReadonlyArray<T>> | Include<"graceful", RemoveReadonlyArray<T>> | Include<"cia", RemoveReadonlyArray<T>> | Include<"counter", RemoveReadonlyArray<T>> | Include<"cron", RemoveReadonlyArray<T>> | Include<"hash", RemoveReadonlyArray<T>> | Include<"checker", RemoveReadonlyArray<T>> | Include<"signer", RemoveReadonlyArray<T>>]["Main"] extends (arg: infer R, ...args: any[]) => any ? R : {}>) => { [k in keyof Pick<{
+}[Include<"schema", RemoveReadonlyArray<T>> | Include<"logger", RemoveReadonlyArray<T>> | Include<"aes", RemoveReadonlyArray<T>> | Include<"request", RemoveReadonlyArray<T>> | Include<"sequelize", RemoveReadonlyArray<T>> | Include<"cache", RemoveReadonlyArray<T>> | Include<"redis", RemoveReadonlyArray<T>> | Include<"counter", RemoveReadonlyArray<T>> | Include<"cron", RemoveReadonlyArray<T>> | Include<"myCia", RemoveReadonlyArray<T>> | Include<"hash", RemoveReadonlyArray<T>> | Include<"rest", RemoveReadonlyArray<T>> | Include<"parallel", RemoveReadonlyArray<T>> | Include<"graceful", RemoveReadonlyArray<T>> | Include<"checker", RemoveReadonlyArray<T>> | Include<"signer", RemoveReadonlyArray<T>>]["Main"] extends (arg: infer R, ...args: any[]) => any ? R : {}>) => { [k in keyof Pick<{
     aes: typeof import("./deps/aes");
     cache: typeof import("./deps/cache");
     checker: typeof import("./deps/checker");
-    cia: typeof import("./deps/cia");
     counter: typeof import("./deps/counter");
     cron: typeof import("./deps/cron");
     graceful: typeof import("./deps/graceful");
     hash: typeof import("./deps/hash");
     logger: typeof import("./deps/logger");
+    myCia: typeof import("./deps/myCia");
     parallel: typeof import("./deps/parallel");
-    redis: typeof import("./deps/redis"); /** 模块名称联合类型 */
+    redis: typeof import("./deps/redis");
     request: typeof import("./deps/request");
     rest: typeof import("./deps/rest");
     schema: typeof import("./deps/schema");
@@ -53,14 +53,14 @@ export declare function Main<T extends Readonly<Array<keyof TDeps>>>(features: T
     aes: typeof import("./deps/aes");
     cache: typeof import("./deps/cache");
     checker: typeof import("./deps/checker");
-    cia: typeof import("./deps/cia");
     counter: typeof import("./deps/counter");
     cron: typeof import("./deps/cron");
     graceful: typeof import("./deps/graceful");
     hash: typeof import("./deps/hash");
     logger: typeof import("./deps/logger");
+    myCia: typeof import("./deps/myCia");
     parallel: typeof import("./deps/parallel");
-    redis: typeof import("./deps/redis"); /** 模块名称联合类型 */
+    redis: typeof import("./deps/redis");
     request: typeof import("./deps/request");
     rest: typeof import("./deps/rest");
     schema: typeof import("./deps/schema");

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export declare type ReadonlyArray2union<T extends ReadonlyArray<any>> = T extends ReadonlyArray<infer A> ? A : never;

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.js

@@ -17,7 +17,7 @@ const md5 = (str) => {
     return hash.update(str.toString()).digest().toString("hex");
 };
 exports.md5 = md5;
-function randStr(len, type) {
+function randStr(len, type = "normal") {
     const dict = type === "strong" || type === "normal" ? RAND_STR_DICT[type] : type;
     const { length } = dict;
     /** 随机字符串的长度不能等于 0 或者负数 */

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@domain.js/main",
-  "version": "0.1.3",
+  "version": "0.1.8",
   "description": "DDD framework",
   "main": "dist/index.js",
-  "bin": "dist/cli/index.js",
+  "bin": {
+    "domain-cli": "dist/cli/index.js"
+  },
   "scripts": {
     "build": "tsc",
     "test": "export NODE_ENV=test && jest ./src --coverage",
@@ -72,8 +74,7 @@
     "mysql2": "^2.3.3",
     "restify": "^8.6.0",
     "restify-errors": "^8.0.2",
-    "sequelize": "^6.9.0",
-    "swagger-ui-restify": "^3.0.8",
+    "sequelize": "6.12.1",
     "type-fest": "^2.8.0",
     "uuid": "^8.3.2",
     "xlsx": "^0.17.4"